Java 入門實戰：一維/二維數組聲明、初始化、遍歷、Arrays工具類與練習題詳解

前言：數組操作的標準化流程

數組是 Java 最基礎的容器，掌握「聲明→分配→賦值→處理」四步驟、靜態初始化語法、越界防護、Arrays 工具類核心方法、二維/鋸齒數組結構與遍歷模板，能高效完成數據存儲與批量處理任務。

---

一、什麼是數組

• 固定長度、同類型、有序、索引從 0 開始的連續內存結構。
• 基本類型存值，引用類型存引用地址。
• 隨機訪問 O(1)，插入刪除 O(n)。

---

二、四步驟標準操作流

1. 聲明數組

// 推薦：類型[] 變量名
int[] scores;
String[] names;
double[][] matrix;

// 不推薦：C 風格
int scores2[];

2. 分配空間（動態初始化）

scores = new int[5];           // 長度 5，默認 0
names = new String[3];         // 長度 3，默認 null
matrix = new double[2][4];     // 規則二維：2 行 4 列

3. 賦值

// 逐個
scores[0] = 76;
scores[1] = 85;

// 循環
for (int i = 0; i < scores.length; i++) {
    scores[i] = (int)(Math.random() * 100);
}

4. 處理/輸出

System.out.println(scores[0]);                    // 單個
System.out.println(Arrays.toString(scores));      // 整體 [76, 85, ...]

---

三、靜態初始化：聲明即賦值

// 一維
int[] scores = new int[] {78, 23, 44, 78};
int[] scores2 = {78, 23, 44, 78}; // 僅限聲明行

// 二維規則
int[][] grid = new int[][] {
    {1, 2, 3},
    {4, 5, 6}
};

// 二維鋸齒（不規則）
int[][] jagged = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};
// 或分步
int[][] jagged2 = new int[3][];
jagged2[0] = new int[2];
jagged2[1] = new int[5];
jagged2[2] = new int[1];

易錯：int[] a = new int[3] {1,2,3}; ❌ 靜態初始化不可指定長度。

---

四、循環遍歷三種方式

1. 普通 for（需索引控制）

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

2. 增強 for / for-each（唯讀遍歷）

for (int val : arr) {
    System.out.print(val + " ");
}
// 編譯器轉為 Iterator 模式，基本類型直接拆箱

3. while 循環

int i = 0;
while (i < arr.length) {
    System.out.print(arr[i++] + " ");
}

---

五、高危陷阱：索引越界

int[] a = new int[2]; // 合法索引 0, 1
System.out.println(a[2]); // 運行時拋出 ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2

• 編譯不報錯，運行崩潰。
• 防範：嚴格用 i < arr.length，避免 <=。
• Java 9+ Objects.checkIndex(index, length) 顯式檢查。

---

六、Arrays 工具類核心方法速查

方法	功能	示例
sort(arr)	原地升序排序	Arrays.sort(nums)
sort(arr, from, to)	區間排序 [from, to)	Arrays.sort(nums, 1, 4)
binarySearch(arr, key)	二分查找（前提已排序）	int idx = Arrays.binarySearch(nums, 5)
toString(arr)	格式化輸出 [e1, e2, ...]	System.out.println(Arrays.toString(arr))
deepToString(arr)	多維遞歸輸出	Arrays.deepToString(matrix)
equals(arr1, arr2)	長度+逐元素比較	Arrays.equals(a, b)
deepEquals(arr1, arr2)	多維遞歸比較	Arrays.deepEquals(m1, m2)
fill(arr, val)	全部填充	Arrays.fill(arr, -1)
fill(arr, from, to, val)	區間填充	Arrays.fill(arr, 2, 5, 0)
copyOf(arr, newLen)	拷貝並調整長度	int[] b = Arrays.copyOf(a, 10)
copyOfRange(arr, from, to)	區間拷貝 [from, to)	int[] sub = Arrays.copyOfRange(a, 1, 4)
stream(arr)	轉流式 API	Arrays.stream(arr).filter(x->x>0).sum()
parallelSort(arr)	並行排序（大數據多核）	Arrays.parallelSort(bigArray)
mismatch(arr1, arr2)	首個不同索引	Arrays.mismatch(a, b)
compare(arr1, arr2)	字典序比較 (Java 9+)	Arrays.compare(a, b)

---

七、二維數組遍歷模板

規則二維

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

鋸齒數組（每行長度不同）

// 必須用 matrix[i].length 而非 matrix[0].length
for (int i = 0; i < jagged.length; i++) {
    for (int j = 0; j < jagged[i].length; j++) {
        System.out.print(jagged[i][j] + " ");
    }
    System.out.println();
}

// for-each 版（自適應行長）
for (int[] row : jagged) {
    for (int val : row) {
        System.out.print(val + " ");
    }
    System.out.println();
}

---

八、練習題精講

題 1：正確聲明並初始化

下列哪項正確？

A. int[] a = new int[3] {1,2,3};          // ❌ 靜態初始化不可指定長度
B. int[] a = {1,2,3};                     // ✅ 正確
C. int a[] = new int[] {1,2,3};           // ✅ 正確（C 風格聲明）
D. int[] a = new int[3]; a = {1,2,3};     // ❌ 賦值語句不能用靜態初始化語法

答案：B、C

題 2：數組拷貝陷阱

int[] a = {1,2,3};
int[] b = a;           // 引用拷貝，指向同一對象
b[0] = 99;
System.out.println(a[0]); // 99

// 正確獨立拷貝
int[] c = Arrays.copyOf(a, a.length);
int[] d = a.clone();   // 淺拷貝，基本類型數組等同深拷貝

題 3：二維數組長度

int[][] m = {{1,2}, {3,4,5}, {6}};
m.length;        // 3 (行數)
m[0].length;     // 2
m[1].length;     // 3
m[2].length;     // 1

題 4：Arrays.sort 對基本類型 vs 對象排序

int[] a = {3,1,2};
Arrays.sort(a); // Dual-Pivot Quicksort，原地修改

String[] s = {"b", "a", "c"};
Arrays.sort(s); // TimSort（穩定），原地修改

// 自定義排序
Arrays.sort(s, (x, y) -> y.compareTo(x)); // 降序

題 5：二分查找前提

int[] a = {1,3,5,7,9};
int idx = Arrays.binarySearch(a, 5); // 返回 2
int idx2 = Arrays.binarySearch(a, 4); // 返回 -3 (插入點 -1 - 2)
// 必須先排序，否則結果未定義

---

九、最佳實踐清單

1. 業務代碼優先集合：ArrayList/List 動態擴容、泛型安全、豐富 API。
2. 性能敏感用數組：演算法核心、大數據處理、JNI、避免裝箱開銷。
3. 聲明用 Type[] name：語義清晰，避免 int a, b[]; 混淆。
4. 遍歷首選 for-each：無索引操作時，可讀性最強，零越界風險。
5. 防禦性拷貝：方法返回內部數組用 copyOf/clone，防外部竄改。
6. 大矩陣扁平化：index = row * COLS + col，一維數組模擬二維，連續內存、單次 GC、緩存友好。
7. 並行排序閾值：parallelSort 適用大數據（>10⁴），小數據開銷大於收益。

---

總結

數組雖簡單，但「長度不可變、索引從 0 起、越界拋異常、基本類型存值引用類型存引用、Arrays 工具類功能豐富、二維數組實為數組的數組」這些核心特性貫穿 Java 開發全過程。熟練掌握聲明初始化語法、三種遍歷模式、靜態/動態初始化區別、鋸齒數組處理、排序查找填充拷貝等高頻操作，並能靈活選擇數組與集合，是寫出高效、健壯 Java 代碼的基本功。