在程序中创建数组

 

数组

数组是一个容器对象，它保存着固定数量的相同类型的值。数组的长度在创建数组时确定。创建后，其长度是固定的。您已经在 "Hello World!" 应用程序的 main 方法中看到了数组的示例。本节将更详细地讨论数组。

数组中的每个项目称为元素，每个元素都通过其数字索引访问。如上图所示，编号从 0 开始。例如，第 6 个元素将通过索引 5 访问。

以下程序 ArrayDemo 创建了一个整数数组，在数组中放入一些值，并将每个值打印到标准输出。

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];

        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
}

该程序的输出为

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000

在实际的编程情况下，您可能会使用支持的循环结构之一来遍历数组的每个元素，而不是像前面的示例那样单独编写每一行。但是，该示例清楚地说明了数组语法。您将在 控制流 部分了解各种循环结构（for、while 和 do-while）。

 

声明一个变量来引用数组

前面的程序使用以下代码行声明了一个数组（名为 anArray）

// declares an array of integers
int[] anArray;

与其他类型变量的声明类似，数组声明有两个部分：数组的类型和数组的名称。数组的类型写为 type[]，其中 type 是所包含元素的数据类型；方括号是表示此变量保存数组的特殊符号。数组的大小不是其类型的一部分（这就是方括号为空的原因）。数组的名称可以是您想要的任何名称，只要它遵循 类 部分中讨论的规则和约定即可。与其他类型的变量一样，声明不会真正创建数组；它只是告诉编译器此变量将保存指定类型的数组。

同样，您可以声明其他类型的数组

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

您也可以将方括号放在数组名称之后

// this form is discouraged
float anArrayOfFloats[];

但是，约定不鼓励这种形式；方括号标识数组类型，应该与类型指定一起出现。

 

创建、初始化和访问数组

创建数组的一种方法是使用 new 运算符。ArrayDemo 程序中的下一条语句分配了一个具有足够内存来容纳 10 个整数元素的数组，并将该数组分配给 anArray 变量。

// create an array of integers
anArray = new int[10];

如果缺少此语句，则编译器会打印类似以下内容的错误，并且编译失败

ArrayDemo.java:4: Variable anArray may not have been initialized.

接下来的几行将值分配给数组的每个元素

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // and so forth

每个数组元素都通过其数字索引访问

System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);

或者，您可以使用快捷语法来创建和初始化数组

int[] anArray = {
    100, 200, 300,
    400, 500, 600,
    700, 800, 900, 1000
};

这里，数组的长度由花括号之间用逗号分隔的值的数量决定。

您还可以通过使用两个或多个方括号集（例如 String[][] names）来声明数组的数组（也称为多维数组）。因此，每个元素都必须通过相应数量的索引值访问。

在 Java 编程语言中，多维数组是一个数组，其组件本身也是数组。这与 C 或 Fortran 中的数组不同。其结果是，允许行长度不同，如下面的 MultiDimArrayDemo 程序所示

class MultiDimArrayDemo {
    public static void main(String[] args) {
        String[][] names = {
            {"Mr. ", "Mrs. ", "Ms. "},
            {"Smith", "Jones"}
        };
        // Mr. Smith
        System.out.println(names[0][0] + names[1][0]);
        // Ms. Jones
        System.out.println(names[0][2] + names[1][1]);
    }
}

该程序的输出为

Mr. Smith
Ms. Jones

最后，您可以使用内置的 length 属性来确定任何数组的大小。以下代码将数组的大小打印到标准输出

System.out.println(anArray.length);

 

复制数组

System 类有一个 arraycopy() 方法，您可以使用它来有效地将数据从一个数组复制到另一个数组

public static void arraycopy(Object src, int srcPos,
                             Object dest, int destPos, int length)

两个 Object 参数指定要从中复制的数组和要复制到的数组。三个 int 参数指定源数组中的起始位置、目标数组中的起始位置以及要复制的数组元素数量。

以下程序 ArrayCopyDemo 声明了一个 String 元素数组。它使用 System.arraycopy() 方法将数组组件的子序列复制到第二个数组中

class ArrayCopyDemo {
    public static void main(String[] args) {
        String[] copyFrom = {
            "Affogato", "Americano", "Cappuccino", "Corretto", "Cortado",
            "Doppio", "Espresso", "Frappucino", "Freddo", "Lungo", "Macchiato",
            "Marocchino", "Ristretto" };

        String[] copyTo = new String[7];
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        for (String coffee : copyTo) {
            System.out.print(coffee + " ");
        }
    }
}

该程序的输出为

Cappuccino Corretto Cortado Doppio Espresso Frappucino Freddo

 

数组操作

数组是编程中一个强大而有用的概念。Java SE 提供了方法来执行与数组相关的某些最常见的操作。例如，ArrayCopyDemo 示例使用 arraycopy() 方法 System 类，而不是手动遍历源数组的元素并将每个元素放入目标数组。这在幕后执行，使开发人员能够仅使用一行代码来调用该方法。

为了方便起见，Java SE 在 java.util.Arrays 类中提供了用于执行数组操作（常见任务，例如复制、排序和搜索数组）的几种方法。例如，前面的示例可以修改为使用 java.util.Arrays 方法 java.util.Arrays 类，如 ArrayCopyOfDemo 示例所示。不同之处在于，使用 java.util.Arrays 方法不需要在调用该方法之前创建目标数组，因为目标数组是由该方法返回的

class ArrayCopyOfDemo {
    public static void main(String[] args) {
        String[] copyFrom = {
            "Affogato", "Americano", "Cappuccino", "Corretto", "Cortado",
            "Doppio", "Espresso", "Frappucino", "Freddo", "Lungo", "Macchiato",
            "Marocchino", "Ristretto" };

        String[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);
        for (String coffee : copyTo) {
            System.out.print(coffee + " ");
        }
    }
}

如您所见，该程序的输出相同，尽管它需要更少的代码行。请注意，java.util.Arrays 方法的第二个参数是将要复制的范围的初始索引（包含），而第三个参数是将要复制的范围的最终索引（不包含）。在本例中，将要复制的范围不包括索引为 9 的数组元素（包含字符串 Lungo）。

java.util.Arrays 类中的方法提供的其他一些有用操作是

• 在数组中搜索特定值以获取其放置的索引（binarySearch() 方法）。
• 比较两个数组以确定它们是否相等（equals() 方法）。
• 填充数组以在每个索引处放置特定值（fill() 方法）。
• 将数组排序为升序。这可以通过使用 sort() 方法顺序执行，也可以通过使用 Java SE 8 中引入的 parallelSort() 方法并发执行。在多处理器系统上对大型数组进行并行排序比顺序数组排序更快。
• 创建一个使用数组作为其源的流（stream() 方法）。例如，以下语句以与前面示例相同的方式打印 copyTo 数组的内容

java.util.Arrays.stream(copyTo).map(coffee -> coffee + " ").forEach(System.out::print);

有关流的更多信息，请参见聚合操作。

• 将数组转换为字符串。 toString() 方法将数组的每个元素转换为字符串，用逗号分隔它们，然后用方括号将它们括起来。例如，以下语句将 copyTo 数组转换为字符串并打印它

System.out.println(java.util.Arrays.toString(copyTo));

此语句打印以下内容

[Cappuccino, Corretto, Cortado, Doppio, Espresso, Frappucino, Freddo]

 

总结变量和数组

Java 编程语言在其术语中使用“字段”和“变量”。实例变量（非静态字段）对于类的每个实例都是唯一的。类变量（静态字段）是用 static 修饰符声明的字段；无论类被实例化多少次，类变量都只有一个副本。局部变量在方法内部存储临时状态。参数是向方法提供额外信息的变量；局部变量和参数始终被归类为“变量”（而不是“字段”。在命名字段或变量时，有一些规则和约定需要遵循（或必须遵循）。

八种基本数据类型是：byte、short、int、long、float、double、boolean 和 char。java.lang.String 类表示字符字符串。编译器将为上述类型的字段分配一个合理的默认值；对于局部变量，永远不会分配默认值。

字面量是固定值的源代码表示。数组是一个容器对象，它保存固定数量的单一类型的值。数组的长度在创建数组时确定。创建后，其长度是固定的。

更多学习