《Java 程序設計》第 5 章

引言

????????在 Java 編程中，數組是一種基礎且重要的數據結構，它允許我們將多個相同類型的元素存儲在一個連續的內存空間中，通過索引快速訪問。掌握數組的使用是學習 Java 集合框架、算法等高級知識的基礎。本章將從數組的創建、使用開始，逐步深入到 Arrays 工具類、二維數組的應用，最后通過實戰案例鞏固所學知識。

思維導圖

5.1 創建和使用數組

5.1.1 數組定義

????????數組是相同數據類型元素的有序集合，它具有固定長度，一旦創建不可改變。在 Java 中，數組屬于引用類型，需要經歷聲明→創建→初始化三個步驟。

數組的聲明方式

// 方式1：數據類型[] 數組名;（推薦，更清晰表示數組類型）
int[] numbers;
String[] names;// 方式2：數據類型 數組名[];（兼容C語言風格）
int scores[];

數組的創建（動態初始化）

????????使用new關鍵字創建數組，指定長度，元素會被賦予默認值（數值型為 0，布爾型為 false，引用類型為 null）：

// 聲明并創建數組
int[] ages = new int[5]; // 創建長度為5的int數組
String[] fruits = new String[3]; // 創建長度為3的String數組

數組的初始化（靜態初始化）

直接指定數組元素的值，長度由元素個數決定：

// 靜態初始化完整格式
int[] nums = new int[]{1, 2, 3, 4, 5};// 簡化格式（最常用）
String[] colors = {"red", "green", "blue"};

數組的訪問

通過索引（從 0 開始）訪問數組元素，使用數組名[索引]：

public class ArrayDefinitionDemo {public static void main(String[] args) {// 靜態初始化數組String[] languages = {"Java", "Python", "C++"};// 訪問數組元素System.out.println("數組長度：" + languages.length); // 輸出：3System.out.println("第一個元素：" + languages[0]); // 輸出：Java// 修改數組元素languages[1] = "JavaScript";System.out.println("修改后第二個元素：" + languages[1]); // 輸出：JavaScript// 遍歷數組（普通for循環）for (int i = 0; i < languages.length; i++) {System.out.println("索引" + i + "：" + languages[i]);}}
}

注意：訪問數組時如果索引超出范圍（>=length或<0），會拋出ArrayIndexOutOfBoundsException異常。

5.1.2 增強的 for 循環

增強 for 循環（foreach 循環）是 Java 5 引入的語法，專門用于遍歷數組或集合，簡化遍歷代碼。

語法格式

for (元素類型 變量名 : 數組名) {// 循環體，變量名表示當前元素
}

普通 for 循環 vs 增強 for 循環

public class ForEachDemo {public static void main(String[] args) {int[] scores = {85, 92, 78, 90, 88};// 普通for循環：可修改元素，需控制索引System.out.println("普通for循環遍歷：");for (int i = 0; i < scores.length; i++) {scores[i] += 2; // 加分操作System.out.print(scores[i] + " ");}// 增強for循環：不可修改元素（變量是副本），無需控制索引System.out.println("\n增強for循環遍歷：");for (int score : scores) {System.out.print(score + " ");}}
}

運行結果

注意：增強 for 循環中不能修改數組元素的值（變量是元素的副本），適合單純的遍歷場景；需要修改元素或使用索引時，仍需用普通 for 循環。

5.1.3 數組元素的復制

????????數組復制是常見操作，Java 提供多種方式實現數組復制：手動復制、System.arraycopy()、Arrays.copyOf()（后續 5.2.3 講解）。

手動復制（循環賦值）

int[] source = {1, 2, 3, 4, 5};
int[] target = new int[source.length];
for (int i = 0; i < source.length; i++) {target[i] = source[i];
}

System.arraycopy () 方法

JDK 提供的 native 方法，效率高，語法：

System.arraycopy(源數組, 源起始索引, 目標數組, 目標起始索引, 復制長度);

示例代碼

public class ArrayCopyDemo {public static void main(String[] args) {int[] source = {10, 20, 30, 40, 50};int[] target = new int[6]; // 目標數組長度6// 復制source的索引1開始的3個元素到target的索引2開始System.arraycopy(source, 1, target, 2, 3);// 遍歷目標數組for (int num : target) {System.out.print(num + " "); // 輸出：0 0 20 30 40 0 }}
}

注意：System.arraycopy()要求目標數組有足夠空間，否則會拋出IndexOutOfBoundsException。

5.1.4 數組參數與返回值

????????數組作為引用類型，可以作為方法的參數或返回值，傳遞的是數組的引用（內存地址）。

數組作為參數（引用傳遞）

// 方法：打印數組元素
public static void printArray(int[] arr) {for (int num : arr) {System.out.print(num + " ");}System.out.println();
}// 方法：修改數組元素（會影響原數組）
public static void modifyArray(int[] arr) {for (int i = 0; i < arr.length; i++) {arr[i] *= 2;}
}

數組作為返回值

// 方法：創建并返回一個int數組
public static int[] createArray(int length) {int[] arr = new int[length];for (int i = 0; i < length; i++) {arr[i] = i + 1;}return arr;
}

完整示例

public class ArrayParamReturnDemo {public static void main(String[] args) {int[] nums = {1, 2, 3, 4};System.out.println("原數組：");printArray(nums); // 輸出：1 2 3 4 modifyArray(nums);System.out.println("修改后數組：");printArray(nums); // 輸出：2 4 6 8 int[] newArr = createArray(5);System.out.println("方法返回的數組：");printArray(newArr); // 輸出：1 2 3 4 5 }// 打印數組public static void printArray(int[] arr) {if (arr == null) {System.out.println("數組為空");return;}for (int num : arr) {System.out.print(num + " ");}System.out.println();}// 修改數組元素public static void modifyArray(int[] arr) {if (arr == null) return;for (int i = 0; i < arr.length; i++) {arr[i] *= 2;}}// 創建數組public static int[] createArray(int length) {if (length <= 0) {return null; // 處理無效長度}int[] arr = new int[length];for (int i = 0; i < length; i++) {arr[i] = i + 1;}return arr;}
}

5.1.5 可變參數的方法

Java 5 引入可變參數（varargs），允許方法接收任意數量的相同類型參數，語法為類型... 參數名。

語法格式

public static 返回類型 方法名(類型... 參數名) {// 方法體中參數名可作為數組使用
}

使用規則

一個方法只能有一個可變參數
可變參數必須是方法的最后一個參數
調用時可傳遞 0 個、1 個或多個參數，也可直接傳遞數組

示例代碼

public class VarargsDemo {public static void main(String[] args) {// 調用可變參數方法sum(); // 0個參數sum(1); // 1個參數sum(1, 2, 3); // 多個參數sum(new int[]{4, 5, 6}); // 傳遞數組}// 可變參數方法：計算多個整數的和public static void sum(int... nums) {int total = 0;for (int num : nums) {total += num;}System.out.println("總和：" + total);}// 混合參數（可變參數在最后）public static void printInfo(String name, int... scores) {System.out.println("姓名：" + name);System.out.println("成績：");for (int score : scores) {System.out.print(score + " ");}System.out.println("\n---");}
}

運行結果

5.1.6 實例：隨機抽取 4 張牌

需求分析

? ? 模擬從 52 張撲克牌中隨機抽取 4 張，不重復。撲克牌由 “花色” 和 “點數” 組成，需避免重復抽取。

實現思路

定義花色數組（紅桃、黑桃、方塊、梅花）和點數數組（A,2-10,J,Q,K）
使用兩個數組記錄已抽取的索引，避免重復
隨機生成花色和點數的索引，檢查是否已抽取，未抽取則記錄并輸出

完整代碼

import java.util.Random;/*** 隨機抽取4張撲克牌示例*/
public class CardDrawing {public static void main(String[] args) {// 定義花色和點數數組String[] suits = {"紅桃", "黑桃", "方塊", "梅花"};String[] ranks = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};// 記錄已抽取的牌的索引（避免重復）boolean[] drawn = new boolean[52]; // 52張牌，初始值為falseint count = 0; // 已抽取的牌數Random random = new Random();System.out.println("隨機抽取的4張牌：");// 循環抽取4張牌while (count < 4) {// 生成隨機索引（0-51）int index = random.nextInt(52);// 如果未抽取過if (!drawn[index]) {drawn[index] = true; // 標記為已抽取count++; // 計數+1// 計算花色和點數索引int suitIndex = index / 13; // 0-3（每13張一種花色）int rankIndex = index % 13; // 0-12// 輸出牌面System.out.println(suits[suitIndex] + ranks[rankIndex]);}}}
}

運行結果（示例）

5.1.7 實例：一個整數棧類

需求分析

? ?實現一個整數棧（Stack），支持入棧（push）、出棧（pop）、查看棧頂元素（peek）、判斷棧空（isEmpty）、判斷棧滿（isFull）等操作。

實現思路

用數組作為棧的底層存儲結構
定義棧頂指針（top），初始值為 - 1（棧空）
入棧：top+1，存入元素；出棧：返回 top 位置元素，top-1

類圖（PlantUML）

class IntStack {- int[] elements  // 存儲棧元素的數組- int top         // 棧頂指針（-1表示棧空）- int capacity    // 棧的容量+ IntStack(int capacity)  // 構造方法：初始化棧容量+ push(int value): boolean  // 入棧+ pop(): Integer  // 出棧（返回null表示棧空）+ peek(): Integer  // 查看棧頂元素+ isEmpty(): boolean  // 判斷棧空+ isFull(): boolean   // 判斷棧滿+ size(): int  // 獲取當前棧元素個數
}

流程圖（入棧操作）

完整代碼

/*** 整數棧類實現*/
public class IntStack {private int[] elements; // 存儲棧元素的數組private int top; // 棧頂指針（-1表示棧空）private int capacity; // 棧的最大容量/*** 構造方法：初始化棧容量* @param capacity 棧的最大容量*/public IntStack(int capacity) {this.capacity = capacity;elements = new int[capacity];top = -1; // 初始棧空}/*** 入棧操作* @param value 要入棧的整數* @return 入棧成功返回true，棧滿則返回false*/public boolean push(int value) {if (isFull()) {System.out.println("棧已滿，無法入棧！");return false;}top++; // 棧頂指針上移elements[top] = value; // 存入元素return true;}/*** 出棧操作* @return 出棧的元素，棧空則返回null*/public Integer pop() {if (isEmpty()) {System.out.println("棧為空，無法出棧！");return null;}int value = elements[top]; // 獲取棧頂元素top--; // 棧頂指針下移return value;}/*** 查看棧頂元素（不出棧）* @return 棧頂元素，棧空則返回null*/public Integer peek() {if (isEmpty()) {return null;}return elements[top];}/*** 判斷棧是否為空* @return 空返回true，否則返回false*/public boolean isEmpty() {return top == -1;}/*** 判斷棧是否已滿* @return 滿返回true，否則返回false*/public boolean isFull() {return top == capacity - 1;}/*** 獲取當前棧中元素個數* @return 元素個數*/public int size() {return top + 1;}/*** 測試棧功能*/public static void main(String[] args) {IntStack stack = new IntStack(3); // 創建容量為3的棧// 測試入棧stack.push(10);stack.push(20);stack.push(30);stack.push(40); // 棧滿，入棧失敗// 測試棧狀態System.out.println("棧是否滿：" + stack.isFull()); // trueSystem.out.println("棧元素個數：" + stack.size()); // 3System.out.println("棧頂元素：" + stack.peek()); // 30// 測試出棧System.out.println("出棧元素：" + stack.pop()); // 30System.out.println("出棧元素：" + stack.pop()); // 20System.out.println("棧元素個數：" + stack.size()); // 1// 繼續出棧System.out.println("出棧元素：" + stack.pop()); // 10System.out.println("出棧元素：" + stack.pop()); // 棧空，返回nullSystem.out.println("棧是否空：" + stack.isEmpty()); // true}
}

運行結果

5.2 Arrays 類

? ?java.util.Arrays類提供了大量靜態方法，用于數組的操作（排序、查找、復制等），簡化數組處理代碼。使用前需導入該類。

5.2.1 數組的排序

? ? Arrays.sort()方法用于對數組進行排序，支持基本數據類型和對象數組（對象需實現Comparable接口）。

示例代碼

import java.util.Arrays;/*** Arrays.sort()排序示例*/
public class ArraysSortDemo {public static void main(String[] args) {// 基本類型數組排序（升序）int[] intArr = {3, 1, 4, 1, 5, 9};Arrays.sort(intArr);System.out.println("排序后的int數組：" + Arrays.toString(intArr));// 字符串數組排序（按字典序）String[] strArr = {"banana", "apple", "orange", "grape"};Arrays.sort(strArr);System.out.println("排序后的字符串數組：" + Arrays.toString(strArr));// 部分排序（從索引1到4，不包含4）int[] partArr = {5, 3, 8, 2, 7, 1};Arrays.sort(partArr, 1, 4); // 排序索引1-3的元素System.out.println("部分排序后的數組：" + Arrays.toString(partArr));}
}

運行結果

5.2.2 元素的查找

? ? Arrays.binarySearch()方法用于在已排序的數組中查找元素，返回元素索引（未找到返回負數）。

語法格式

// 在整個數組中查找
static int binarySearch(數組, 目標值)// 在指定范圍（fromIndex到toIndex）中查找
static int binarySearch(數組, fromIndex, toIndex, 目標值)

示例代碼

import java.util.Arrays;/*** Arrays.binarySearch()查找示例*/
public class ArraysSearchDemo {public static void main(String[] args) {int[] arr = {2, 4, 6, 8, 10, 12};// 查找存在的元素int index1 = Arrays.binarySearch(arr, 8);System.out.println("元素8的索引：" + index1); // 輸出：3// 查找不存在的元素int index2 = Arrays.binarySearch(arr, 5);System.out.println("元素5的索引（未找到）：" + index2); // 輸出：-3（插入點為2，-(2+1)=-3）// 范圍查找int index3 = Arrays.binarySearch(arr, 1, 4, 6); // 在索引1-3中查找6System.out.println("范圍查找元素6的索引：" + index3); // 輸出：2}
}

注意：使用binarySearch()前必須確保數組已排序，否則結果不可靠！

5.2.3 數組元素的復制

? Arrays類提供copyOf()和copyOfRange()方法復制數組，相比System.arraycopy()更簡潔。

方法說明

copyOf(原數組, 新長度)：復制原數組到新數組，新長度可大于或小于原長度（不足補默認值，超出截斷）
copyOfRange(原數組, 起始索引, 結束索引)：復制原數組從起始索引到結束索引（不包含）的元素

示例代碼

import java.util.Arrays;/*** Arrays.copyOf()和copyOfRange()示例*/
public class ArraysCopyDemo {public static void main(String[] args) {int[] original = {1, 2, 3, 4, 5};// copyOf()：新長度等于原長度int[] copy1 = Arrays.copyOf(original, 5);System.out.println("copy1：" + Arrays.toString(copy1)); // [1,2,3,4,5]// copyOf()：新長度大于原長度（補默認值0）int[] copy2 = Arrays.copyOf(original, 7);System.out.println("copy2：" + Arrays.toString(copy2)); // [1,2,3,4,5,0,0]// copyOf()：新長度小于原長度（截斷）int[] copy3 = Arrays.copyOf(original, 3);System.out.println("copy3：" + Arrays.toString(copy3)); // [1,2,3]// copyOfRange()：復制索引1到4（不包含4）的元素int[] rangeCopy = Arrays.copyOfRange(original, 1, 4);System.out.println("rangeCopy：" + Arrays.toString(rangeCopy)); // [2,3,4]}
}

5.2.4 填充數組元素

Arrays.fill()方法用于為數組的指定范圍填充相同的值。

示例代碼

import java.util.Arrays;/*** Arrays.fill()填充數組示例*/
public class ArraysFillDemo {public static void main(String[] args) {// 初始化數組int[] arr1 = new int[5];// 填充整個數組為8Arrays.fill(arr1, 8);System.out.println("填充整個數組：" + Arrays.toString(arr1)); // [8,8,8,8,8]// 部分填充：索引1到4（不包含4）填充為5int[] arr2 = {1, 2, 3, 4, 5, 6};Arrays.fill(arr2, 1, 4, 5);System.out.println("部分填充后：" + Arrays.toString(arr2)); // [1,5,5,5,5,6]// 二維數組填充（填充每行的數組）String[][] strArr = new String[3][3];for (int i = 0; i < strArr.length; i++) {Arrays.fill(strArr[i], "A" + i); // 第i行填充"Ai"}System.out.println("二維數組填充后：");for (String[] row : strArr) {System.out.println(Arrays.toString(row));}}
}

5.2.5 數組的比較

? ?Arrays.equals()用于比較兩個數組是否相等（長度相同且對應元素相等）；Arrays.deepEquals()用于比較多維數組。

示例代碼

import java.util.Arrays;/*** 數組比較示例*/
public class ArraysEqualsDemo {public static void main(String[] args) {// 一維數組比較int[] arr1 = {1, 2, 3};int[] arr2 = {1, 2, 3};int[] arr3 = {1, 2, 4};System.out.println("arr1與arr2是否相等：" + Arrays.equals(arr1, arr2)); // trueSystem.out.println("arr1與arr3是否相等：" + Arrays.equals(arr1, arr3)); // false// 長度不同的數組int[] arr4 = {1, 2};System.out.println("arr1與arr4是否相等：" + Arrays.equals(arr1, arr4)); // false// 二維數組比較（需用deepEquals）int[][] deepArr1 = {{1, 2}, {3, 4}};int[][] deepArr2 = {{1, 2}, {3, 4}};System.out.println("二維數組用equals比較：" + Arrays.equals(deepArr1, deepArr2)); // false（比較的是引用）System.out.println("二維數組用deepEquals比較：" + Arrays.deepEquals(deepArr1, deepArr2)); // true}
}

5.3 二維數組

? ? 二維數組本質是 “數組的數組”，即每個元素都是一個一維數組。常用于表示表格、矩陣等二維結構。

5.3.1 二維數組定義

定義方式

// 方式1：聲明并指定行數和列數
數據類型[][] 數組名 = new 數據類型[行數][列數];// 方式2：聲明時不指定列數（不規則數組）
數據類型[][] 數組名 = new 數據類型[行數][];// 方式3：靜態初始化
數據類型[][] 數組名 = {{元素1,元素2}, {元素3,元素4}, ...};

示例代碼

/*** 二維數組定義示例*/
public class TwoDArrayDefine {public static void main(String[] args) {// 方式1：指定行數和列數（3行2列）int[][] arr1 = new int[3][2];System.out.println("arr1行數：" + arr1.length); // 3System.out.println("arr1第0行列數：" + arr1[0].length); // 2// 方式2：只指定行數，不指定列數（后續需初始化每行）int[][] arr2 = new int[2][];arr2[0] = new int[3]; // 第0行3列arr2[1] = new int[4]; // 第1行4列System.out.println("arr2第1行列數：" + arr2[1].length); // 4// 方式3：靜態初始化String[][] arr3 = {{"張三", "男"}, {"李四", "女"}, {"王五", "男"}};System.out.println("arr3第2行第0列：" + arr3[2][0]); // 王五}
}

5.3.2 數組元素的使用

二維數組元素通過數組名[行索引][列索引]訪問，行索引和列索引均從 0 開始。

示例代碼

/*** 二維數組元素訪問示例*/
public class TwoDArrayAccess {public static void main(String[] args) {// 創建3行3列的二維數組int[][] matrix = new int[3][3];// 給元素賦值（填充為1-9）int value = 1;for (int i = 0; i < matrix.length; i++) { // 遍歷行for (int j = 0; j < matrix[i].length; j++) { // 遍歷列matrix[i][j] = value++;}}// 訪問并打印元素System.out.println("二維數組元素：");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(); // 換行}// 增強for循環遍歷System.out.println("增強for循環遍歷：");for (int[] row : matrix) { // 每行是一個int數組for (int num : row) {System.out.print(num + " ");}System.out.println();}}
}

運行結果

5.3.3 數組初始化器

? ?二維數組的初始化包括靜態初始化（直接指定元素）和動態初始化（先指定行數，再初始化每行）。

示例代碼

import java.util.Arrays; // 添加Arrays導入/*** 二維數組初始化示例*/
public class TwoDArrayInit {public static void main(String[] args) {// 靜態初始化：直接指定所有元素String[][] names = {{"Alice", "Bob"},{"Charlie", "David", "Eve"},{"Frank"}};// 打印靜態初始化的數組System.out.println("靜態初始化的二維數組：");for (String[] row : names) {System.out.println(Arrays.toString(row)); // 需要Arrays導入}// 動態初始化：先指定行數，再初始化每行int[][] dynamicArr = new int[2][];// 修復初始化語法錯誤dynamicArr[0] = new int[2]; // 先聲明大小dynamicArr[0][0] = 10;     // 再賦值dynamicArr[0][1] = 20;dynamicArr[1] = new int[3]; // 先聲明大小dynamicArr[1][0] = 30;      // 再賦值dynamicArr[1][1] = 40;dynamicArr[1][2] = 50;// 或者使用簡化的正確語法：// dynamicArr[0] = new int[]{10, 20}; // 正確語法// dynamicArr[1] = new int[]{30, 40, 50}; // 正確語法System.out.println("\n動態初始化的二維數組：");for (int[] row : dynamicArr) {System.out.println(Arrays.toString(row)); // 需要Arrays導入}}
}

運行結果

5.3.4 實例：矩陣乘法

需求分析

? ? 實現兩個矩陣的乘法：若 A 是 m×n 矩陣，B 是 n×p 矩陣，則乘積 C 是 m×p 矩陣，其中C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + ... + A[i][n-1]*B[n-1][j]。

流程圖（矩陣乘法）

完整代碼

import java.util.Arrays;/*** 矩陣乘法示例*/
public class MatrixMultiplication {/*** 矩陣乘法* @param A 第一個矩陣（m×n）* @param B 第二個矩陣（n×p）* @return 乘積矩陣C（m×p），若不可乘返回null*/public static int[][] multiply(int[][] A, int[][] B) {// 檢查矩陣合法性if (A == null || B == null) return null;int m = A.length; // A的行數int n = A[0].length; // A的列數int p = B[0].length; // B的列數// 檢查A的列數是否等于B的行數if (n != B.length) {System.out.println("矩陣不可乘！A的列數（" + n + "）≠ B的行數（" + B.length + "）");return null;}// 創建結果矩陣（m行p列）int[][] C = new int[m][p];// 計算矩陣乘積for (int i = 0; i < m; i++) { // 遍歷A的行for (int j = 0; j < p; j++) { // 遍歷B的列int sum = 0;for (int k = 0; k < n; k++) { // 累加計算C[i][j]sum += A[i][k] * B[k][j];}C[i][j] = sum;}}return C;}/*** 打印矩陣* @param matrix 要打印的矩陣*/public static void printMatrix(int[][] matrix) {if (matrix == null) {System.out.println("矩陣為空");return;}for (int[] row : matrix) {System.out.println(Arrays.toString(row));}}public static void main(String[] args) {// 定義兩個可乘的矩陣（2×3 和 3×2）int[][] A = {{1, 2, 3},{4, 5, 6}};int[][] B = {{7, 8},{9, 10},{11, 12}};System.out.println("矩陣A：");printMatrix(A);System.out.println("\n矩陣B：");printMatrix(B);// 計算乘積int[][] C = multiply(A, B);System.out.println("\n矩陣乘積C = A×B：");printMatrix(C);}
}

運行結果

5.3.5 不規則二維數組

不規則二維數組指每行的列數不同的二維數組，創建時只需指定行數，每行單獨初始化。

示例代碼

import java.util.Arrays;/*** 不規則二維數組示例*/
public class IrregularArray {public static void main(String[] args) {// 創建3行的不規則數組（不指定列數）int[][] irregular = new int[3][];// 初始化每行（列數不同）irregular[0] = new int[2]; // 第0行2列irregular[1] = new int[4]; // 第1行4列irregular[2] = new int[1]; // 第2行1列// 填充數據for (int i = 0; i < irregular.length; i++) {for (int j = 0; j < irregular[i].length; j++) {irregular[i][j] = i + j;}}// 打印不規則數組System.out.println("不規則二維數組：");for (int[] row : irregular) {System.out.println(Arrays.toString(row));}// 應用：楊輝三角（前5行）int[][] yanghui = new int[5][];for (int i = 0; i < yanghui.length; i++) {yanghui[i] = new int[i + 1]; // 第i行有i+1個元素yanghui[i][0] = 1; // 每行第一個元素為1yanghui[i][i] = 1; // 每行最后一個元素為1// 填充中間元素（i>1時）for (int j = 1; j < i; j++) {yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];}}System.out.println("\n楊輝三角：");for (int[] row : yanghui) {System.out.println(Arrays.toString(row));}}
}

運行結果

5.4 小結

本章主要學習了 Java 數組的核心知識，包括：

一維數組：
- 定義與初始化（靜態 / 動態）
- 增強 for 循環遍歷
- 數組復制（System.arraycopy()、Arrays.copyOf()）
- 數組作為參數和返回值，可變參數方法
Arrays 工具類：
- 排序（sort()）、查找（binarySearch()）
- 復制（copyOf()、copyOfRange()）
- 填充（fill()）、比較（equals()、deepEquals()）
二維數組：
- 定義與初始化（規則 / 不規則）
- 元素訪問與遍歷
- 矩陣乘法等實際應用

????????數組是 Java 中處理批量數據的基礎結構，掌握數組操作是學習集合、算法的前提。實際開發中需注意數組索引越界、空指針等異常，合理使用Arrays類簡化代碼。

編程練習

練習 1：數組元素求和與平均值

編寫方法計算數組所有元素的和與平均值。

import java.util.Arrays; // 添加Arrays導入
/*** 數組求和與平均值練習*/
public class ArraySumAvg {public static void main(String[] args) {double[] numbers = {1.5, 2.5, 3.5, 4.5, 5.5};double[] result = calculateSumAndAvg(numbers);System.out.println("數組元素：" + Arrays.toString(numbers));System.out.println("總和：" + result[0]);System.out.println("平均值：" + result[1]);}/*** 計算數組的總和與平均值* @param arr 輸入數組* @return 長度為2的數組，[0]是總和，[1]是平均值*/public static double[] calculateSumAndAvg(double[] arr) {if (arr == null || arr.length == 0) {return new double[]{0, 0}; // 空數組返回0}double sum = 0;for (double num : arr) {sum += num;}double avg = sum / arr.length;return new double[]{sum, avg};}
}

練習 2：查找數組最大值與索引

編寫方法查找數組中的最大值及其所有索引。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;/*** 查找數組最大值與索引練習*/
public class FindMaxIndex {public static void main(String[] args) {int[] arr = {5, 3, 8, 8, 2, 8, 7};int max = findMax(arr);List<Integer> indices = findMaxIndices(arr, max);System.out.println("數組：" + Arrays.toString(arr));System.out.println("最大值：" + max);System.out.println("最大值索引：" + indices);}// 查找數組最大值public static int findMax(int[] arr) {if (arr == null || arr.length == 0) {throw new IllegalArgumentException("數組不能為空！");}int max = arr[0];for (int num : arr) {if (num > max) {max = num;}}return max;}// 查找最大值的所有索引public static List<Integer> findMaxIndices(int[] arr, int max) {List<Integer> indices = new ArrayList<>();for (int i = 0; i < arr.length; i++) {if (arr[i] == max) {indices.add(i);}}return indices;}
}

練習 3：二維數組轉置

將 m×n 的矩陣轉置為 n×m 的矩陣（行變列，列變行）。

import java.util.Arrays;/*** 二維數組轉置練習*/
public class MatrixTranspose {public static void main(String[] args) {int[][] matrix = {{1, 2, 3},{4, 5, 6}};System.out.println("原矩陣（2×3）：");printMatrix(matrix);int[][] transposed = transpose(matrix);System.out.println("\n轉置后矩陣（3×2）：");printMatrix(transposed);}/*** 矩陣轉置* @param matrix 原矩陣（m×n）* @return 轉置后的矩陣（n×m）*/public static int[][] transpose(int[][] matrix) {if (matrix == null || matrix.length == 0) return null;int m = matrix.length; // 原矩陣行數int n = matrix[0].length; // 原矩陣列數int[][] result = new int[n][m]; // 轉置后n行m列for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {result[j][i] = matrix[i][j]; // 行變列，列變行}}return result;}// 打印矩陣public static void printMatrix(int[][] matrix) {for (int[] row : matrix) {System.out.println(Arrays.toString(row));}}
}