在Java中使用数组(Array)

数组可以是int, char等原始类型，也可以是对象的引用。对于原始类型，实际值会存储在连续的位置；对于对象类型，存储在堆段中。

一维数组

一维数组的声明

type varName[];
或者
type[] varName;

数组的声明有两部分：类型(type)和名字(varName)。类型声明数组中元素的类型，可以创建各种类型的数据。

// Both are valid declarations.
int intArrayAfter[];
int[] intArrayBefore;

byte byteArray[];
double doubleArray[];
char charArray[];

private class MyClass {
}

MyClass myClassArray[];

Object[] ao;        // array of Object
Collection[] ca;

上述只是声明数组，告诉编译器变量存放整形数据。存放真实的数据，还需要使用new进行构造。

数组初始化

当数组声明后，仅仅只是数组的引用被创建，需要使用如下的方式分配内存给数组。

varName = new type[size];

大小(size)指的是数组中元素的个数，使用new进行内存分配时，必须指定类型(type)和大小(size)。

int intArraySep[];  // declaring array
intArraySep = new int[20];  // allocating memory to array
或者
int[] intArrayConn = new int[20];   // combining both statements in one

注：通过new进行内存分配的数组，对于数字类型会初始化为0，布尔类型会初始化为false，引用类型会初始化为null。

在循环中使用数组

public static void main(String[] args) {
    int[] arr;
    arr = new int[2];

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

    for (int i = 0; i < arr.length; i++)
        System.out.println("Element at index " + i + ": " + arr[i]);
}

输出

Element at index 0: 10
Element at index 1: 20

对象数组

构建一个类，然后声明对象数组。

public class Student {
    public int rollNum;
    public String name;

    public Student(int rollNum, String name) {
        this.rollNum = rollNum;
        this.name = name;
    }

    public static void main(String[] args) {
        // Declares an array of integers.
        Student[] s;
        // Allocating memory for 2 objects of type Student.
        s = new Student[2];
        // Initialize the elements.
        s[0] = new Student(1, "aman");
        s[1] = new Student(2, "vaibhav");

        for (int i = 0; i < s.length; i++)
            System.out.println("Element at " + i + ": " +
                    s[i].rollNum + " " + s[i].name);
    }
}

输出

Element at 0: 1 aman
Element at 1: 2 vaibhav

访问s[3]会导致数组越界。

多维数组

多维数组可以理解为数组的数组，也就是说数组里面是数组的引用。

int[][] multiArray = {{2, 7, 9}, {3, 6, 1}, {7, 4, 2}};
for (int i = 0; i < 3 ; i++) {
    for (int j = 0; j < 3; j++)
        System.out.print(multiArray[i][j] + " ");
    System.out.println();
}

输出

2 7 9 
3 6 1 
7 4 2

多维数组

传递数组

像变量一样，数组也可以传递进入方法中。

public static void sum(int[] arr) {
    // Getting sum of array values.
    int sum = 0;
    for (int i = 0; i < arr.length; i++)
        sum += arr[i];
    System.out.println("Sum of array values: " + sum);
}

public static void main(String[] args) {
    int a[] = {3, 1, 2, 5, 4};
    // Passing array to method sum.
    sum(a);
｝

输出

Sum of array values: 15

返回数组

Java可以从方法中返回数组

public static int[] returnArrayMethod() {
    return new int[]{1, 2, 3};
}

数组的复制

当复制一维数组时，会进行深度复制(Deep copy)。

public class ArrayCopy {
    public static void main(String[] args) {
        int singleArray[] = {1, 2, 3};
        int cloneSingleArray[] = singleArray.clone();

        System.out.println(singleArray == cloneSingleArray);
    }
}

结果会输出false，两个变量指向不同的内存。

深度复制

当复制多维数组时，只是进行浅复制(Shallow copy)。

public class ArrayCopy {
    public static void main(String[] args) {
        int multiArray[][] = {{1, 2, 3}, {4, 5}};
        int cloneMultiArray[][] = multiArray.clone();

        System.out.println(multiArray == cloneMultiArray);
        System.out.println(multiArray[0] == cloneMultiArray[0]);
        System.out.println(multiArray[1] == cloneMultiArray[1]);
    }
}

输出

false
true
true

说明子数组是共享的。