数组

数组是存储同类型数据的容器，本课学习Java中数组的使用。

什么是数组

数组是固定大小的同类型数据集合。

数组特点

特点	说明
固定大小	创建后大小不能改变
同类型	所有元素类型相同
连续存储	元素在内存中连续存放
索引访问	通过索引（从0开始）访问元素

声明与初始化

方式1：先声明后初始化

JAVA

// 声明数组
int[] arr;

// 初始化（分配空间）
arr = new int[5];  // 5个元素，默认值为0

方式2：声明并初始化

JAVA

// 指定大小
int[] arr = new int[5];

// 直接赋值
int[] arr = {1, 2, 3, 4, 5};

示例：数组初始化

JAVA

public class ArrayInit {
    public static void main(String[] args) {
        // 方式1：指定大小
        int[] arr1 = new int[3];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        
        // 方式2：直接赋值
        int[] arr2 = {10, 20, 30};
        
        // 方式3：new + 赋值
        int[] arr3 = new int[]{10, 20, 30};
        
        System.out.println(arr2[0]);  // 10
        System.out.println(arr2[1]);  // 20
        System.out.println(arr2[2]);  // 30
    }
}

⚠️ 注意： 数组索引从0开始，最大索引是长度-1。访问越界会抛出ArrayIndexOutOfBoundsException。

访问与修改

JAVA

int[] arr = {10, 20, 30, 40, 50};

// 访问元素
int first = arr[0];   // 10
int third = arr[2];   // 30

// 修改元素
arr[1] = 200;         // 把20改为200

// 获取数组长度
int len = arr.length; // 5

遍历数组

方式1：普通for循环

JAVA

int[] arr = {10, 20, 30, 40, 50};

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

方式2：for-each循环

JAVA

int[] arr = {10, 20, 30, 40, 50};

for (int num : arr) {
    System.out.println(num);
}

示例：求平均值

JAVA

public class ArrayAverage {
    public static void main(String[] args) {
        int[] scores = {85, 92, 78, 96, 88};
        int sum = 0;
        
        for (int score : scores) {
            sum += score;
        }
        
        double avg = (double) sum / scores.length;
        System.out.println("平均分：" + avg);  // 87.8
    }
}

Arrays工具类

java.util.Arrays提供了数组操作的工具方法。

常用方法

方法	说明	示例
`sort()`	排序	`Arrays.sort(arr)`
`copyOf()`	复制	`Arrays.copyOf(arr, newLen)`
`fill()`	填充	`Arrays.fill(arr, value)`
`equals()`	比较	`Arrays.equals(arr1, arr2)`
`toString()`	转字符串	`Arrays.toString(arr)`
`binarySearch()`	二分查找	`Arrays.binarySearch(arr, key)`

示例：Arrays使用

JAVA

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        
        // 排序
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
        // [1, 2, 3, 5, 8, 9]
        
        // 复制
        int[] arr2 = Arrays.copyOf(arr, 3);
        System.out.println("复制前3个：" + Arrays.toString(arr2));
        // [1, 2, 3]
        
        // 填充
        int[] arr3 = new int[5];
        Arrays.fill(arr3, 100);
        System.out.println("填充后：" + Arrays.toString(arr3));
        // [100, 100, 100, 100, 100]
        
        // 查找（需要先排序）
        int index = Arrays.binarySearch(arr, 5);
        System.out.println("5的索引：" + index);  // 3
    }
}

二维数组

二维数组可以理解为"数组的数组"。

声明与初始化

JAVA

// 方式1：指定大小
int[][] matrix = new int[3][4];  // 3行4列

// 方式2：直接赋值
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

示例：遍历二维数组

JAVA

public class TwoDArrayDemo {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 遍历
        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();
        }
        // 输出：
        // 1 2 3
        // 4 5 6
        // 7 8 9
    }
}

示例：矩阵转置

JAVA

public class MatrixTranspose {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        
        // 转置：2行3列 → 3行2列
        int[][] transposed = new int[3][2];
        
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                transposed[j][i] = matrix[i][j];
            }
        }
        
        // 打印转置后的矩阵
        for (int[] row : transposed) {
            System.out.println(java.util.Arrays.toString(row));
        }
        // [1, 4]
        // [2, 5]
        // [3, 6]
    }
}

可变参数

可变参数允许方法接受不定数量的参数。

语法

JAVA

public static int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

示例：可变参数

JAVA

public class VarargsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1, 2));           // 3
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(1, 2, 3, 4, 5));  // 15
    }
    
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

⚠️ 注意： 可变参数必须是方法的最后一个参数，一个方法只能有一个可变参数。

常见数组算法

示例：冒泡排序

JAVA

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        System.out.println(java.util.Arrays.toString(arr));
        // [1, 2, 3, 5, 8, 9]
    }
}

示例：求最大值

JAVA

public class FindMax {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        int max = arr[0];
        
        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }
        
        System.out.println("最大值：" + max);  // 9
    }
}

❓ 常见问题

Q 数组长度可以改变吗？

A 不可以。数组长度固定，如果需要动态大小，使用ArrayList。

Q 数组有默认值吗？

A 有。int默认0，double默认0.0，boolean默认false，引用类型默认null。

Q Arrays.sort()是什么排序算法？

A 对于基本类型用双轴快排，对于对象类型用TimSort（归并排序的变种）。

📖 小节

数组是固定大小的同类型数据集合，索引从0开始
遍历用普通for或for-each
Arrays工具类提供排序、复制、填充等方法
二维数组可以理解为数组的数组
可变参数允许方法接受不定数量的参数

📝 作业

数组操作： 创建一个10个元素的数组，赋值1-10，然后逆序输出
查找最大值： 找出数组中的最大值和最小值
冒泡排序： 实现冒泡排序算法，对数组进行升序排序

下一课

下一课我们将学习实战：基础综合，综合运用前7课的知识。