Java数组知识大全

1. 数组的定义与创建

（1）数组的定义

在Java中，数组是一种用于存储相同类型数据的集合。数组的大小是固定的，一旦定义就不能改变。数组的定义格式如下：

数据类型[] 数组名;
1

例如：

int[] numbers; // 定义一个整型数组
1

（2）数组的创建及初始化

在Java中，数组的创建和初始化通常一起进行：

数据类型[] 数组名 = new 数据类型[数组大小];
1

例如：

int[] numbers = new int[5]; // 创建一个大小为5的整型数组
1

初始化值：在创建数组的同时，可以直接为数组元素赋值：

int[] numbers = {1, 2, 3, 4, 5}; // 创建一个大小为5的整型数组，并初始化
1

补充：

（1）数组的创建及初始化的分离

虽然通常我们会一起创建和初始化数组，但也可以先声明再初始化：

int[] numbers; // 声明数组
numbers = new int[5]; // 初始化数组
1
2

或者先声明并初始化部分值，再后续赋值：

int[] numbers = {1, 2, 3}; // 初始化部分值
numbers[3] = 4; // 后续赋值
1
2

（2）数组不进行初始化时会有默认值

如果数组在声明时没有进行初始化，它的元素将被自动赋值为该数据类型的默认值（例如，对于int类型，默认值为0；对于boolean类型，默认值为false等）。

2. 数组的遍历

（1）使用for循环

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}
1
2
3
4

（2）使用增强for循环（也称为for-each循环）

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}
1
2
3
4

（3）使用Array.toString方法（注意：需要导入java.util.Arrays）

import java.util.Arrays;

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(numbers));
1
2
3
4

3. 数组中常用的API

这些API通常在java.util.Arrays类中定义。

（1）binarySearch

用于在已排序的数组中查找指定元素，并返回其索引。

（2）copyOf

用于创建一个新数组，它是原始数组的副本。

（3）copyOfRange

用于从原始数组中复制一个范围到新数组中。

（4）equals

用于比较两个数组是否相等。

（5）fill

用于将指定的值分配给数组的所有元素。

（6）sort

用于对数组进行排序。

（7）toString

以下是使用java.util.Arrays类中上述API的代码示例：

（1）binarySearch

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] sortedArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int index = Arrays.binarySearch(sortedArray, 5);
        if (index >= 0) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found. Insertion point: -" + (-index - 1));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

（2）copyOf

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] copiedArray = Arrays.copyOf(originalArray, 7); // 创建长度为7的新数组，并将originalArray的元素复制到其中
        for (int i = 0; i < copiedArray.length; i++) {
            if (i < originalArray.length) {
                System.out.print(originalArray[i] + " "); // 输出原始数组的元素
            } else {
                System.out.print(0 + " "); // 输出新添加的默认元素（整型数组默认为0）
            }
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

（3）copyOfRange

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] copiedRange = Arrays.copyOfRange(originalArray, 2, 6); // 复制索引2（包含）到索引6（不包含）之间的元素
        System.out.println(Arrays.toString(copiedRange)); // 输出：[3, 4, 5, 6]
    }
}
1
2
3
4
5
6
7
8
9

（4）equals

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {1, 2, 3, 4, 6};
        
        System.out.println(Arrays.equals(array1, array2)); // 输出：true
        System.out.println(Arrays.equals(array1, array3)); // 输出：false
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

（5）fill

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] array = new int[5];
        Arrays.fill(array, 7); // 将数组的所有元素设置为7
        System.out.println(Arrays.toString(array)); // 输出：[7, 7, 7, 7, 7]
    }
}
1
2
3
4
5
6
7
8
9

（6）sort

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] array = {9, 5, 1, 8, 3};
        Arrays.sort(array); // 对数组进行排序
        System.out.println(Arrays.toString(array)); // 输出：[1, 3, 5, 8, 9]
    }
}
1
2
3
4
5
6
7
8
9

（7）toString

import java.util.Arrays;

public class ArrayExamples {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(array)); // 输出：[1, 2, 3, 4, 5]
    }
}
1
2
3
4
5
6
7
8

这些示例展示了java.util.Arrays类中一些常用API的基本用法。请注意，在使用binarySearch方法时，数组必须是已排序的，否则结果可能是不正确的。

4. 二维数组

（1）二维数组的定义

二维数组可以看作是一个数组的数组，即数组的每一个元素又是一个数组。

int[][] matrix = new int[3][4]; // 定义一个3行4列的二维整型数组
1

或者初始化时直接赋值：

int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
1

（2）二维数组的遍历

【1】使用for循环遍历二维数组

当使用for循环遍历二维数组时，你需要两个嵌套的for循环：一个用于遍历行（外部循环），另一个用于遍历列（内部循环）。

下面是一个示例代码，展示了如何使用for循环遍历二维数组并打印其内容：

public class TwoDArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        // 使用for循环遍历二维数组
        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
10
11
12
13

在这个示例中，外部循环变量i用于遍历二维数组的行，内部循环变量j用于遍历每一行的列。matrix.length给出了二维数组的行数，而matrix[i].length给出了第i行的列数。在内部循环中，我们使用System.out.print()打印当前元素，并在每个元素后添加一个空格。当内部循环完成一行的遍历后，我们使用System.out.println()来换行，以便下一行的元素从新的一行开始打印。

【2】使用增强for循环遍历二维数组

虽然增强for循环（也称为for-each循环）在遍历一维数组时非常方便，但它在直接遍历二维数组时有一定的限制。这是因为增强for循环需要一个明确的可迭代对象（如数组或实现了Iterable接口的集合），而二维数组本质上是一个数组的数组，不是一个直接的可迭代对象。

然而，你可以使用增强for循环遍历二维数组的一维数组（即行），然后对每个一维数组使用传统的for循环或增强for循环来遍历其元素。

下面是一个示例代码，展示了如何使用增强for循环遍历二维数组的行，并使用传统的for循环遍历每一行的元素：

public class TwoDArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        // 使用增强for循环遍历二维数组的行
        for (int[] row : matrix) {
            // 使用传统的for循环遍历每一行的元素
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println(); // 打印完一行后换行
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，外部增强for循环变量row表示二维数组中的每一行（即一个一维数组）。然后，我们对每个row使用内部的增强for循环来遍历并打印其元素。

【3】使用Arrays.deepToString方法打印二维数组

如果你想要将整个二维数组转换为一个字符串以便打印或记录，你可以使用Arrays.deepToString方法（需要导入java.util.Arrays）。这个方法会递归地将多维数组转换为字符串。

下面是一个示例代码：

import java.util.Arrays;

public class TwoDArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        // 使用Arrays.deepToString方法打印二维数组
        System.out.println(Arrays.deepToString(matrix));
    }
}
1
2
3
4
5
6
7
8
9
10

运行这段代码将输出类似于以下的字符串：

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

1
2

数组和二维数组的内存分配

下滑查看解决方法

在Java中，当你创建一个数组时，实际上是在内存中为数组分配了一块连续的空间。对于一维数组，所有的元素都是连续存储的。而对于二维数组，它实际上是一个数组的数组，每个元素都是一个指向一维数组的引用。这些一维数组（即二维数组的行）可以存储在不同的内存位置，但它们各自内部的元素是连续存储的。

多维数组

除了二维数组，Java还支持更多维的数组，如三维数组、四维数组等。不过，在实际编程中，多维数组的使用相对较少，因为它们的结构相对复杂，难以直观地理解和操作。

数组作为参数传递和返回值

在Java中，数组可以作为方法的参数传递，也可以作为方法的返回值。当数组作为参数传递时，实际上传递的是数组的引用，而不是数组本身。因此，在方法内部对数组的任何修改都会影响到原始数组。

数组的可变性和不可变性

Java中的数组是可变的，即数组的大小和内容都可以在运行时被修改。然而，有一些数据结构（如Java中的Arrays.asList()返回的列表）虽然基于数组，但它们是不可变的，即不能修改它们的大小或内容。

数组与集合（Collections）

虽然数组和集合（如ArrayList、HashSet等）都是用来存储数据的，但它们之间有一些重要的区别。数组是静态的，一旦创建，其大小就不能改变。而集合是动态的，可以在运行时添加或删除元素。此外，集合还提供了许多有用的方法来操作和管理数据，如排序、搜索等。

数组与性能

数组在内存中的存储是连续的，这使得它们在处理大量数据时具有较高的性能。然而，由于数组的大小是固定的，因此在使用数组时需要预先估计所需的空间，以避免空间不足或浪费。

数组与泛型（Generics）

Java中的泛型允许你在编译时检查类型安全，但它并不直接支持泛型数组。即你不能创建一个泛型数组（如T[] array），但你可以创建一个泛型集合（如List<T> list）。如果需要处理泛型数据，建议使用集合而不是数组。

总结

数组是Java中一种基本且重要的数据结构，用于存储相同类型的数据。二维数组和多维数组是数组的扩展，可以存储更复杂的数据结构。然而，在实际编程中，需要根据具体的需求和场景来选择使用数组、集合还是其他数据结构。