Java 数组

Java - 数组

Java 中的数组提供了一种存储具有固定大小、顺序排列且元素类型相同的数据集合的方式。可以将数组视为一个编号的变量列表，所有变量都具有相同的类型。

你可以声明一个单独的数组变量 scores，而不是声明像 score1、score2、score3 这样的单个变量，并通过索引访问元素：scores[0]、scores[1]、scores[2]。

本教程涵盖 Java 中数组的声明、创建、初始化和处理。

声明数组变量

要使用数组，首先需要声明一个变量来持有它的引用。你必须指定数组将要存储的元素的数据类型。

// 推荐的现代语法：
dataType[] arrayRefVar;

// 可用，但不推荐 (C/C++ 风格)：
dataType arrayRefVar[];

**注意：**在现代 Java 代码中，强烈推荐使用 dataType[] arrayRefVar; 这种风格，以获得更好的可读性。

声明示例：

double[] temperatures; // 声明一个用于存放 double 类型的数组变量
String[] names;       // 声明一个用于存放 String 类型的数组变量
int[] counts;

创建和初始化数组

声明只创建了引用变量；它不会在内存中创建实际的数组对象。你需要使用 new 运算符创建数组，并指定大小（元素数量）。

// 1. 声明变量
double[] myList;
// 2. 创建数组对象并分配其引用
myList = new double[10]; // 创建一个可以存放 10 个 double 的数组

这些步骤通常会合并：

dataType[] arrayRefVar = new dataType[arraySize];

// 示例：
int[] scores = new int[5]; // 创建一个存放 5 个 int 的数组

使用 new 创建时，元素会自动初始化为其默认值（数值类型为 0，boolean 类型为 false，对象类型为 null）。

你也可以使用数组初始化器（花括号 {}）一步到位创建和初始化数组：

dataType[] arrayRefVar = { value0, value1, ..., valueK };

// 示例：
double[] rates = { 1.9, 2.9, 3.4, 3.5 }; // 大小由值推断
String[] weekdays = { "Mon", "Tue", "Wed", "Thu", "Fri" };

访问数组元素

通过基于零的索引来访问数组元素（第一个元素位于索引 0）。有效的索引范围是 0 到 arrayRefVar.length - 1。

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

// 访问元素：
int firstNumber = numbers[0]; // firstNumber 值为 10
int thirdNumber = numbers[2]; // thirdNumber 值为 30

// 修改元素：
numbers[1] = 25; // 将第二个元素修改为 25

// 获取数组长度 (元素数量)：
int size = numbers.length; // size 值为 4

尝试访问超出有效范围的索引（例如 numbers[4] 或 numbers[-1]）将在运行时导致 ArrayIndexOutOfBoundsException。

处理数组

循环通常用于处理数组元素。

使用传统的 for 循环：

这种循环允许你访问索引，这在你需要修改元素或知道元素位置时很有用。

public class ArrayProcessing {
    public static void main(String[] args) {
        double[] myList = { 1.9, 2.9, 3.4, 3.5 };

        // 打印所有元素
        System.out.println("Elements:");
        for (int i = 0; i < myList.length; i++) {
            System.out.print(myList[i] + " ");
        }
        System.out.println(); // 换行

        // 计算总和
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is: " + total);

        // 查找最大元素
        double max = myList[0]; // 最初假设第一个是最大值
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max) {
                max = myList[i];
            }
        }
        System.out.println("Max is: " + max);
    }
}

预期输出：

Elements:
1.9 2.9 3.4 3.5
Total is: 11.7
Max is: 3.5

使用增强型 for 循环 (foreach)：

增强型 for 循环（在 Java 5 中引入）提供了一种更简单的语法来遍历所有元素，当你不需要索引时。它通常更易读。

public class EnhancedForLoop {
    public static void main(String[] args) {
        double[] myList = { 1.9, 2.9, 3.4, 3.5 };

        // 使用增强型 for 循环打印所有元素
        System.out.println("Elements using enhanced for loop:");
        for (double element : myList) { // 理解为：“对于 myList 中的每个 double 类型的 element”
            System.out.println(element);
        }

        // 使用增强型 for 循环计算总和
        double sum = 0;
        for (double value : myList) {
            sum += value;
        }
        System.out.println("Sum calculated with enhanced loop: " + sum);
    }
}

预期输出：

Elements using enhanced for loop:
1.9
2.9
3.4
3.5
Sum calculated with enhanced loop: 11.7

将数组传递给方法

你可以像传递其他对象类型一样将数组传递给方法。请记住，数组是按引用传递的，这意味着方法接收到的是对原始数组的引用的副本。在方法内部对数组元素进行的更改将影响原始数组。

public class ArrayMethods {

    // 打印数组元素的方法
    public static void printArray(int[] array) {
        System.out.print("Array elements: [ ");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + (i < array.length - 1 ? ", " : ""));
        }
        System.out.println(" ]");
    }

    // 修改数组元素的方法
    public static void modifyElement(int[] arr, int index, int newValue) {
        if (index >= 0 && index < arr.length) {
             arr[index] = newValue; // 修改原始数组
        }
    }

    public static void main(String[] args) {
        int[] myNumbers = { 3, 1, 2, 6, 4, 2 };

        printArray(myNumbers); // 将数组传递给方法
        // 输出: Array elements: [ 3, 1, 2, 6, 4, 2 ]

        modifyElement(myNumbers, 1, 99); // 修改索引为 1 的元素
        printArray(myNumbers); // 查看原始数组的变化
        // 输出: Array elements: [ 3, 99, 2, 6, 4, 2 ]

        // 你也可以直接传递匿名数组：
        printArray(new int[] { 10, 20, 30 });
        // 输出: Array elements: [ 10, 20, 30 ]
    }
}

从方法返回数组

方法也可以返回数组。

public class ReturnArray {

    // 创建并返回数组的反向副本的方法
    public static int[] reverse(int[] list) {
        int[] result = new int[list.length];
        for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
            result[j] = list[i];
        }
        return result; // 返回新创建的反向数组
    }

    public static void main(String[] args) {
        int[] original = { 1, 2, 3, 4, 5 };
        int[] reversedArray = reverse(original);

        System.out.print("Original: ");
        ArrayMethods.printArray(original); // 使用上一个示例中的 printArray 方法
        // 输出: Original: Array elements: [ 1, 2, 3, 4, 5 ]

        System.out.print("Reversed: ");
        ArrayMethods.printArray(reversedArray);
        // 输出: Reversed: Array elements: [ 5, 4, 3, 2, 1 ]
    }
}

Arrays 工具类

java.util.Arrays 类提供了有用的静态方法，用于执行常见的数组操作，例如排序、搜索、填充和比较。

序号	方法签名 (简化)	描述
1	static void sort(primitive[] a) / sort(Object[] a)	将指定的数组按升序排序（数值或字典顺序）。在原地修改数组。
2	static int binarySearch(primitive[] a, primitive key) / binarySearch(Object[] a, Object key)	使用二分搜索算法在已排序的数组中搜索指定的 key。如果找到，则返回 key 的索引；否则，返回 (-(插入点) - 1)。
3	static boolean equals(primitive[] a, primitive[] a2) / equals(Object[] a, Object[] a2)	如果两个数组包含相同的元素且顺序相同，则返回 true。对于对象数组，使用元素的 equals() 方法进行比较。
4	static void fill(primitive[] a, primitive val) / fill(Object[] a, Object val)	将指定的值赋给指定数组的每个元素。
5	static primitive[] copyOf(primitive[] original, int newLength) / T[] copyOf(T[] original, int newLength)	复制指定的数组，必要时进行截断或填充默认值（0, false, null），以获得指定的长度。
6	static String toString(primitive[] a) / toString(Object[] a)	返回指定数组内容的 String 表示形式（例如 “[1, 2, 3]”）。用于打印数组内容很有用。

使用 Arrays 工具类方法的示例：

import java.util.Arrays;

public class ArraysUtilityDemo {
    public static void main(String[] args) {
        int[] numbers = { 5, 2, 8, 1, 9 };

        System.out.println("Original array: " + Arrays.toString(numbers));
        // 输出: Original array: [5, 2, 8, 1, 9]

        Arrays.sort(numbers);
        System.out.println("Sorted array:   " + Arrays.toString(numbers));
        // 输出: Sorted array:   [1, 2, 5, 8, 9]

        int index = Arrays.binarySearch(numbers, 8);
        System.out.println("Index of 8: " + index); // 输出: Index of 8: 3

        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 100);
        System.out.println("Filled array:   " + Arrays.toString(filledArray));
        // 输出: Filled array:   [100, 100, 100, 100, 100]

        int[] numbersCopy = Arrays.copyOf(numbers, numbers.length);
        System.out.println("Are numbers and numbersCopy equal? " + Arrays.equals(numbers, numbersCopy));
        // 输出: Are numbers and numbersCopy equal? true
    }
}

数组 vs. ArrayList

虽然数组是基础的，但它们具有固定大小。如果你需要一个大小可以动态增长或收缩的集合，java.util.ArrayList 类（Java 集合框架的一部分）通常是更灵活的选择。ArrayList 提供了方便添加、删除和管理元素的方法。

当元素数量不确定或频繁变化时，考虑使用 ArrayList。