《Java 程序设计》第 5 章 - 数组详解

啊阿狸不会拉杆

发布于 2026-01-21 12:46:11

1560

引言

在 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); // 输出：3
        System.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张牌，初始值为false
        int 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()); // true
        System.out.println("栈元素个数：" + stack.size()); // 3
        System.out.println("栈顶元素：" + stack.peek()); // 30

        // 测试出栈
        System.out.println("出栈元素：" + stack.pop()); // 30
        System.out.println("出栈元素：" + stack.pop()); // 20
        System.out.println("栈元素个数：" + stack.size()); // 1

        // 继续出栈
        System.out.println("出栈元素：" + stack.pop()); // 10
        System.out.println("出栈元素：" + stack.pop()); // 栈空，返回null
        System.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中查找6
        System.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];
        // 填充整个数组为8
        Arrays.fill(arr1, 8);
        System.out.println("填充整个数组：" + Arrays.toString(arr1)); // [8,8,8,8,8]
        
        // 部分填充：索引1到4（不包含4）填充为5
        int[] 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)); // true
        System.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); // 3
        System.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; // 每行第一个元素为1
            yanghui[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));
        }
    }
}

结语

数组是 Java 编程中不可或缺的数据结构，本章通过理论讲解和实战案例，详细介绍了数组的创建、使用、工具类及二维数组的应用。希望通过本文的学习，你能熟练掌握数组操作，并能在实际开发中灵活运用。后续章节将学习更复杂的集合框架，数组知识是其重要基础，建议多动手练习巩固哦！

如果有任何问题或建议，欢迎在评论区留言交流～

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2026-01-20，如有侵权请联系 [email protected] 删除

数组

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 [email protected] 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！