制作阵列有两种主要方法：

对于空数组：

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

对于一个初始化的数组：

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

您还可以创建多维数组，如下所示：

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

以基元类型int为例。有几种方法可以声明和int数组：

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

在所有这些中，可以使用inti[]而不是int[]i。

对于反射，可以使用（Type[]）Array.newInstance（Type.class，capacity）；

注意，在方法参数中。。。表示变量参数。本质上，任何数量的参数都可以。用代码更容易解释：

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

在该方法中，varargs被视为普通的int[]。类型只能在方法参数中使用，因此int.i=newint[]｛｝不会编译。

请注意，当将int[]传递给方法（或任何其他Type[]）时，不能使用第三种方法。在语句int[]i=*{a，b，c，d，etc}*中，编译器假设{…}表示int[]。但这是因为您正在声明一个变量。将数组传递给方法时，声明必须是newType[capartment]或newType[]｛…｝。

多维数组

多维数组更难处理。本质上，2D阵列是阵列的阵列。int[][]表示int[]的数组。关键是，如果int[][]声明为int[x][y]，则最大索引为i[x-1][y-1]。基本上，矩形int[3][5]是：

[0, 0] [1, 0] [2, 0]
[0, 1] [1, 1] [2, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3]
[0, 4] [1, 4] [2, 4]

有时我用它来初始化字符串数组：

private static final String[] PROPS = "lastStart,storetime,tstore".split(",");

它以更昂贵的初始化为代价，减少了报价混乱。

此外，如果您需要更动态的内容，可以使用List界面。这不会表现得很好，但更灵活：

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

声明对象引用数组：

class Animal {}

class Horse extends Animal {
    public static void main(String[] args) {

        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();

        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();

        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();

        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

也是有效的，但我更喜欢在类型后面加括号，因为更容易看出变量的类型实际上是一个数组。