Java_数组_基本概念

多维数组

在Java中，对于多维数组，使用“数组的数组”来实现，即高维数组的每一个元素是一个低维数组，例如：

    int[][] a = new int[2][5];

这是一个矩阵数组，可以这样理解：该语句声明了一个二维数组a，该数组含有两个元素，每个元素为一个一维数组，每个一维数组含有5个元素。
其实，Java中并不存在真正的多维数组，只是使用这种“数组的数组”方式来实现的。也因为如此，不同于C/C++，Java中的多维数组可以不是矩阵数组，例如：

    int[][] a = new int[2][];
    a[0] = new int[4];
    a[1] = new int[5];

以上语句声明的就是非矩阵多维数组，其中，a[0]含有4个元素，a[1]含有5个元素。数组的维数在（1~255）之间。

数组成员

在数组中，可以认为数组中含有length这一成员变量，该变量为int类型，并且声明为public、final，通过该成员可以获取数组的长度。不过，length成员是隐式的，不能通过Class对象的getFields方法获取。
所有数组类继承Object类，并且实现了java.lang.Cloneable与java.io.Serializable接口，因此，下面的程序是合法的：

package deep;

import java.io.Serializable;

public class Array {
    public static void main(String[] args) {
        int[] a = new int[3];
        Object o = a;
        Cloneable c = a;
        Serializable s = a;
    }
}

由于数组继承Object类，因此自然也就继承了Object类中所有生命为public与protected的方法。下面通过程序查看数组的成员：

package deep;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ArrayMember {
    public static void main(String[] args) {
        Class<int[]> c = int[].class;
        System.out.println("数组的父类：");
        Class<?> superClass = c.getSuperclass();
        System.out.println(superClass.getCanonicalName());
        System.out.println("数组实现的接口：");
        Class<?>[] interfaces = c.getInterfaces();
        for (Class<?> inter : interfaces) {
            System.out.println(inter.getCanonicalName());
        }
        System.out.println("数组的public成员变量：");
        Field[] fields = c.getFields();
        for (Field field : fields) {
            System.out.println(field.toGenericString());
        }
        System.out.println("数组的public方法：");
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            System.out.println(method.toGenericString());
        }
    }
}

运行结果：
数组的父类：
java.lang.Object
数组实现的接口：
java.lang.Cloneable
java.io.Serializable
数组的public成员变量：
数组的public方法：
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class

数组的clone方法

数组重写了Object类的clone方法，并将其访问权限修改为public，因此，可以通过数组的引用访问clone方法，可以实现数组复制，并且满足（x为数组引用）：

    x.clone() != x;

不过数组的clone方法为浅复制。仅能保证clone方法返回的数组与原数组的地址不同，而对于数组的元素则没有复制。也就是说，如果数组的元素是引用类型，则原数组元素与复制的数组元素依然指向相同的对象。这就会导致当原数组的某个元素修改内部数据时，相对应复制数组的元素也会随之修改，反之亦然，因为原数组与复制数组的元素指向相同的对象。

数组的输出

当使用System.out对象（PrintStream类的对象）输出数组对象时，char类型的数组与其他类型的数组在输出的表现上有所不同。对于其他类型，调用的是：

    public void print(Object obj)

而对于char类型的数组，调用的是其重载的方法：

    public void print(char s[])

例：

package deep;

public class CharArray {
    public static void main(String[] args) {
        boolean[] bool = new boolean[4];
        byte[] b = new byte[4];
        short[] s = new short[4];
        int[] i = new int[4];
        long[] l = new long[4];
        float[] f = new float[4];
        double[] d = new double[4];
        String[] str = new String[4];
        char[] c = new char[] { 'J', 'a', 'v', 'a' };
        System.out.println(bool);
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(str);
        System.out.println(c);
    }
}

运行结果：
[Z@3781efb9
[B@33a17727
[S@2d95bbec
[I@41649a55
[J@33d063fd
[F@3654919e
[D@6a2437ef
[Ljava.lang.String;@6fd46259
Java

除了char类型的数组输出字符以外，其他类型的数组输出的是toString方法返回的结果（toString方法从Object类中继承）。