Java 数组初始化

1. 概述

一个 数组 是一种数据结构，它允许我们存储和操作相同数据类型的一系列元素。数组具有固定的大小，该大小在初始化期间确定，并且在运行时无法更改。

在本教程中，我们将了解如何声明一个数组。 此外，我们将检查初始化数组的不同方法以及它们之间的细微差别。

2. 了解数组

在 Java 中，数组是可存储相同数据类型多个元素的类。 我们可以通过索引访问数组中的所有元素，这些索引是从零开始的数字位置。 此外，数组的长度代表它可以容纳的总元素数

在上面的图像中，我们有一个包含八个项目的单维数组。

值得注意的是，如果我们尝试访问数组有效索引范围之外的元素，它会抛出 ArrayIndexOutOfBoundsException。

3. 声明和初始化一维数组

我们可以很容易地通过 指定其数据类型，后跟方括号和数组名称 来声明数组

int[] numbers;

在上面的代码中，我们声明了一个未初始化的int类型数组。

或者，我们可以将方括号放在数组名称之后，但 这种方法不太常见

int numbers[];

此外，我们必须初始化数组才能使用它。 初始化涉及使用 new 关键字分配内存并指定数组长度

var numbers = new int[7];

在上面的代码中，我们初始化一个numbers数组来保存七个int类型的元素。

初始化后，我们可以使用它们的索引为单个元素赋值

numbers[0] = 10;
numbers[1] = 20;

这里，我们将10 和20 添加到索引0和1，分别。

此外，我们可以使用其索引检索元素值

assertEquals(20, numbers[1]);

在上面的代码中，我们断言索引一中的元素是20。

可以在单个步骤中声明和初始化数组:

int[] numbers = new int[5];

值得注意的是，数组的长度始终是固定的，并且在初始化后无法扩展。

或者，我们可以使用变量指定数组的长度

int length = 7;
int[] numbers = new int[length];

这里，我们声明一个变量用作数组的长度。 重要的是，length 只能是int类型。 任何其他类型除了int都会抛出不兼容的类型错误。

4. 声明未知大小的数组

当我们声明一个数组时，知道大小不是必需的。 我们可以 将数组赋值为null或一个空数组

int[] numbers = null;

int[] numbers = new int[0];

但是我们**需要在初始化时知道它的尺寸**，因为Java虚拟机必须为其保留连续的内存块。正如我们之前讨论的，我们可以使用new关键字初始化一个数组

int[] numbers =  new int[5];

如果我们要调整数组的大小，可以通过创建一个更大尺寸的数组并将之前的数组元素复制到新数组来完成

int newSize = 10; // New desired size
int[] newArray = new int[newSize];

// Copy elements from the old array to the new array
System.arraycopy(numbers, 0, newArray, 0, numbers.length);

numbers = newArray // reference to new array

如果我们允许使用ArrayList，那么对于动态调整大小，我们应该始终使用ArrayList

// we can add elements dynamically without specifying the size
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);

ArrayList内部使用数组和System.arrayCopy() 来支持动态调整大小。

5. 数组元素的默认值

在初始化时，**数组的元素会自动分配基于数组数据类型的默认值**。这些值代表了在显式分配任何值之前数组元素的初始状态。

int、short、long、float和double数据类型的数组会将所有元素默认设置为零

int[] array = new int[5];
assertArrayEquals(new int[] { 0, 0, 0, 0, 0 }, array);

此外，对于boolean数组，所有元素的默认值都是false

boolean[] array = new boolean[5];
assertArrayEquals(new boolean[] { false, false, false, false, false }, array);

最后，对于对象类型数组（如String），所有元素的默认值都设置为null

String[] array = new String[5];
assertArrayEquals(new String[] { null, null, null, null, null }, array);

值得注意的是，当我们使用或访问数组的元素而没有显式分配值时，我们实际上在使用或访问默认值。

6. 使用值初始化数组

此外，我们可以在初始化期间为数组分配值。**这通常被称为数组字面量**

String[] brand = new String[] { "Toyota", "Mercedes", "BMW", "Volkswagen", "Skoda" };

在上面的代码中，我们使用五个品牌名称初始化了一个字符串数组。花括号内的元素总数决定了数组的长度/大小。

此外，对于原始数据类型，我们可以省略数组类型

int[] array = { 1, 2, 3, 4, 5 };

此外，**在使用var关键字进行类型推断时，我们不能在没有new关键字的情况下初始化数组字面量**

var array = {1, 2, 3, 4, 5};

上面的代码会导致编译错误。

要与数组字面量一起使用var关键字，我们必须引入new关键字，从而允许编译器从赋值的右侧推断类型

var arr = new int[]{1,2,3,4,5};

这里，编译器可以推断这是一个整数数组。

7. 使用Arrays.fill()添加值到数组

java.util.Arrays类具有几个名为fill()的方法，它们接受不同类型的参数并将整个数组填充为相同的值

long array[] = new long[5];
Arrays.fill(array, 30);

当我们需要使用相同的值更新数组的多个元素时，此方法非常有用。

该方法还有几种替代方法，可将数组的给定范围设置为特定值

int[] array = new int[5];
Arrays.fill(array, 0, 3, -50);

这里，fill() 方法分别接受已初始化的数组、开始填充的索引、结束填充的索引（不包括）以及值本身作为参数。数组的前三个元素设置为-50，其余元素保留其默认值，即零。

值得注意的是，如果在开始索引和结束索引之间的范围大于数组的大小，则会抛出ArrayIndexOutOfBoundsException。

8. 使用Arrays.copyOf()复制数组

Arrays.copyOf()方法通过从现有数组复制元素来创建新数组。该方法有许多重载，它们接受不同类型的参数。

让我们看一个快速的例子

int[] array = { 1, 2, 3, 4, 5 };
int[] copy = Arrays.copyOf(array, 5);

在此示例中需要注意几点

• 该方法接受两个参数——源数组和要创建的新数组的所需长度。
• 如果长度大于要复制的数组的长度，则额外的元素将使用其类型的默认值进行初始化。
• 如果源数组未初始化，则会抛出NullPointerException。

9. 使用Arrays.setAll()添加值到数组

Arrays.setAll()方法使用生成器函数设置数组的所有元素。当我们需要将遵循特定模式或逻辑的值添加到数组时，此方法非常有用。

让我们看一个使用Arrays.setAll()方法的例子

int[] numbers = new int[5];
Arrays.setAll(numbers, i -> i * 2);
assertArrayEquals(new int[] {0, 2, 4, 6, 8}, numbers);

在上面的代码中，我们创建了一个int数据类型的数组，并使用setAll() 方法用偶数填充它。

这里是另一个示例，演示了一个更复杂的生成器函数。

int[] array = new int[20];
Arrays.setAll(array, p -> p > 9 ? 0 : p);

// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

在这里，生成器函数将数组的前十个元素设置为它们各自的索引，并将剩余元素设置为零。

如果生成器函数为null，则会抛出NullPointerException。

10. 使用ArrayUtils.clone()克隆数组

让我们利用来自Apache Commons Lang 3的ArrayUtils.clone() API，它通过创建另一个数组的直接副本来初始化一个数组。

char[] array = new char[] {'a', 'b', 'c'};
char[] copy = ArrayUtils.clone(array);

请注意，此方法针对所有原始类型进行了重载。

11. 声明和初始化二维数组

此外，让我们看看如何声明一个二维数组。

int[][] matrix;

在上面的代码中，我们通过指定两组方括号来声明一个int数据类型的二维数组。让我们初始化数组并指定行数和列数。

matrix = new int[2][5];

我们可以将其视为一个具有两行五列的数组。

让我们使用嵌套索引为各个元素赋值，其中第一个索引表示行，第二个索引表示列。

matrix[0][0] = 10;
matrix[0][1] = 20;
matrix[0][2] = 30;
matrix[0][3] = 40;
matrix[0][4] = 50;
matrix[1][0] = 60;
matrix[1][1] = 70;
matrix[1][2] = 80;
matrix[1][3] = 90;
matrix[1][4] = 100;

我们可以通过指定行和列索引来检索二维数组中的值。

assertEquals(20, matrix[0][1]);

在上面的代码中，我们检索行0和列1的数组值。

或者，我们可以使用不太常用的语法来初始化二维数组。

int[] array[] = new int[5][5];

此外，我们可以使用嵌套的大括号使用字面量初始化二维数组。

 int [][] twoDArray = { { 1, 2, 3 }, { 4, 5, 6 } };

在上面的代码中，我们初始化了一个int类型的二维数组，其中包含两个一维数组，它们代表我们数组的两行。

12. 使用for循环向数组添加值

我们可以使用循环将值单独分配给数组的每个元素。当我们需要基于特定条件或计算填充数组时，此方法可能很有用。

让我们看一个使用基于循环的方法的例子。

int[] array = new int [3];
for (int i = 0; i < array.length; i++) {
    array[i] = i + 2;
}

在上面的例子中，我们使用一个循环为每个元素赋值。在这种情况下，我们将值i + 2赋给索引i处的元素。

对于多维数组，我们可以使用嵌套循环遍历每个维度并为元素赋值。

int[][] matrix = new int[3][4];
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        matrix[i][j] = i * 4 + j;
    }
}

在这里，我们使用嵌套for循环分别遍历行和列。我们将每个元素赋值为i * 4 + j，该值是根据行和列索引计算得出的。

13. 使用Stream API初始化数组

Stream API提供了方便的方法，用于从元素流创建数组，包括Arrays.stream()、IntStream.of()、DoubleStream.of()以及许多其他方法。这些方法允许我们使用指定的值初始化数组。

让我们看一个使用Instream.of() 方法来初始化和填充数组的示例。

 int[] values = IntStream.of(1, 2, 3, 4, 5).toArray();

在这里，我们创建一个包含五个值的IntStream，并使用toArray()方法将其转换为整数数组。

此外，我们可以使用Stream API初始化更高维度的数组。让我们使用这种方法初始化一个二维数组。

int[][] matrix = IntStream.range(0, 3)
  .mapToObj(i -> IntStream.range(0, 4).map(j -> i * 4 + j).toArray())
  .toArray(int[][]::new);

首先，我们使用IntStream.range(0, 3)生成一个整数流，对应于matrix中行的索引。 接下来，我们使用mapToObj() 方法将原始流中的每个整数转换为一个整数数组。 然后，我们生成另一个整数流，对应于matrix中每一行的列索引。

最后，我们使用toArray(int[][]::new)方法将整数数组流转换为一个二维数组，这是一个方法引用，用于创建一个新的二维数组。

14. 高维数组

此外，我们还可以拥有多于两个维度的数组。 根据具体的使用情况，我们可以拥有一个三维数组、一个四维数组，等等。 方括号的数量决定了维度。

让我们看看如何声明和初始化一个三维数组

int[][][] threeDArray = new int[3][4][5];

在上面的代码中，我们有三个方括号来表示这是一个三维数组。 第一个方括号[3] 表示数组的深度。 它指示三维数组包含的二维数组的数量。 在这种情况下，我们在三维数组中有三个二维数组。

让我们向第一个二维数组添加一个元素

threeDArray[0][0][1] = 4;

这里，第一个索引[0]表示三维数组中的第一个二维数组，第二个索引[0]表示第一个二维数组的第一行，第三个索引[1]表示第一个二维数组的第一列的第二个元素。

此外，让我们向第二个二维数组添加一个元素

threeDArray[1][0][0] = 6;

首先，我们通过索引[1]指示第二个二维数组。 然后，我们在该二维数组的第一行第一列添加一个元素。

简而言之，三维数组是二维数组的数组.

最后，四维数组本质上是三维数组的数组。

15. 结论

在本文中，我们探讨了在Java中初始化数组的不同方法。 此外，我们还学习了如何声明和分配内存给任何类型的数组，包括一维数组和多维数组。

此外，我们还看到了填充数组值的不同方法，包括使用索引单独分配值，以及在声明时使用值初始化数组。