java 数组(翻译自Java Tutorials)

原文出自 http://www.cnblogs.com/ggjucheng/archive/2012/12/17/2821925.html

英文出自 http://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

数组

数组是一个对象容器，持有固定数目，同一类型的值。当数组创建时，数组的长度就建立了。创建后，它的长度就是固定的。你已经看过了数组的例子，main方法的 "Hello World!"程序。这个章节讨论数组的更多细节。

数组的每个成员，成为元素，每个元素通过数字索引访问。如上图解，数字索引从0开始，第9个元素，通过索引8访问。

下面的程序，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;
        // etc.
        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

在真实世界方案中，最大的可能是使用一个循环构，遍历数组中的每个元素，而不是像上面每行写一行代码。但是，例子清晰解说了数组的语法。

声明数组变量

上面的程序，使用下面的代码声明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; // etc.

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

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参数指定源数组src和目标数组dest。剩下的三个int参数指明源数组的开始位置，目标数组的开始位置，要拷贝的数组的元素个数。

接下来的程序，ArrayCopyDemo，声明一个char数组，拼写"decaffeinated",使用arraycopy拷贝第一个数组的字串到第二个数组：

class ArrayCopyDemo {
    public static void main(String[] args) {
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
                'i', 'n', 'a', 't', 'e', 'd' };
        char[] copyTo = new char[7];

        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        System.out.println(new String(copyTo));
    }
}

程序输出如下：

caffein