Java面向对象编程-第14章数组

一、数组变量的声明
以下均是合法的：

int [] scores1;
int scores2[];
String[] name1;
String name2[];
int[][] arry1;    //二维整型数组
int arry2[][];

但要注意在数组变量声明的时候不能指定数组长度。
以下代码是非法的，编译出错。

int[3] age;  
int age[3];
int age[1][2];

二、数组对象的创建
如下代码创建了一个int型数组，存放100个int类型的数据：

int[] scores=new int[100];

上面代码中的new语句执行的步骤为：（1）在堆区中为数组分配内存空间，代码创建了一个包含100个元素的int数组，每个元素占据4个字节，数组总共占据400个字节。（2）为每个元素赋默认值，这里int类型的默认值为0。（3）将该引用返回给scores。
数组对象创建后，其长度是固定不可改变的，但数组变量可以改变其引用的数组对象。如下代码：

int[] scores;
scores=new int[4];
scores=new int[3];

三、访问数组元素和数组长度
数组中可以通过索引（下标）访问其各个元素，索引（下标）从0开始。所有数组都有一个length属性，表示数组长度，其声明形式为：

public final length;

属性length为public公开型，所以可以访问，又是final型的，所以不可改变。
数组变量在引用一个数组对象后才可以访问其元素，否则会抛出空指针异常。
当数组元素为引用类型时，数组中存放的是对象的引用而非对象本身。

四、数组的初始化
数组创建后，各个元素被自动赋予其对应数据类型的默认值。但也可以直接显式给其赋值：

int[] a=new int[5];
for(int i=0;i<a.length;i++)
    a[i]=i;

也可以如下直接赋值：

int[] a=new int[]{0,1,2,3,4};
char[] c=new Char[]{'a','b','c'};
String[] s={"Monday","Tuesday"};

但在显式赋值中不能显式指定数组长度，如下代码非法：

int[] a=new int[2]{1,2};   //编译出错

赋值也必须在声明数组变量的语句中使用，不能单独使用，如下代码也是非法的：

int[] a;
a={1,2};  //编译出错

五、多维数组
假设某个宾馆有三层楼，每层都有4个房间，数组元素表示住客姓名，可以用以下代码描述：

String[][] rooms=new String[3][4];
rooms[0]=new String[]{"Tom","Jack","Tonny","Marry"};
rooms[1]=new String[]{"Edison",null,"Melly","Robin"};
rooms[2]=new String[]{"Edison",null,"Melly","Robin"};

也可以如下：

String[][] rooms={
    {"Tom","Jack","Tonny","Marry"},
    {"Edison",null,"Melly","Robin"},
    {"Edison",null,"Melly","Robin"}
};  

对于上述数组，数组长度为第一维的长度，即rooms.length==3。

如果每一层的房间数不相同，即第一维为3，第二维不确定，可以如下声明数组变量：

String[][] rooms=new String[3][];
rooms[0]=new String[]{"Tom","Jack","Marry"};
rooms[1]=new String[]{"Edison",null};
rooms[2]=new String[]{"Edison",null,"Melly","Robin"};

同样也可以如下：

String[][] rooms={
    {"Tom","Jack","Marry"},
    {"Edison",null},
    {"Edison",null,"Melly","Robin"}
};

对于该数组，数组长度依然为第一维的长度，即rooms.length==3;第二维的长度可以通过rooms[i].length去访问。

public class ArrayTest {

    public static void main(String[] args) {
        String[][] rooms=new String[3][];
        rooms[0]=new String[]{"Tom",null,"Marry"};
        rooms[1]=new String[]{"Edison","Robin"};
        rooms[2]=new String[]{"Edison",null,"Melly","Robin"};

        //打印房间的住客姓名
        for(int i=0;i<rooms.length;i++){
            System.out.println("第"+(i+1)+"层总共有"+rooms[i].length+"个房间：");
            for(int j=0;j<rooms[i].length;j++){
                System.out.print(((i+1)*100+j+1)+"房：");
                if(rooms[i][j]==null)
                    System.out.print("没有住客。");
                else
                    System.out.print(rooms[i][j]);
                System.out.println();
            }
        }
    }
}

六、调用数组对象的方法
数组继承了Object类，因此继承了Object类的所有方法，通过下例加深理解：

public class Test {

    public static void main(String[] args) {
        int[] a=new int[4];
        int[] b=new int[4];
        int[] c=a;
        int[][][] d=new int[2][3][4];
        System.out.println(a instanceof Object);
        System.out.println(a instanceof int[]);
        System.out.println(d[0] instanceof int[][]);
        System.out.println(d[0][2] instanceof int[]);
        System.out.println(d instanceof int[][][]);
        System.out.println(a.equals(b));
        System.out.println(a.equals(c));
    }
}

运行结果如下：

true
true
true
true
true
false
true

七、把数组作为方法参数或返回值
在下例中change()方法有两种重载形式，对应的参数分别为数组类型和int类型，即引用类型和基本类型。
通过结果可以看出，对于第一种change()方法可以交换数组的值，而对于参数为基本类型的第二种change()方法不能交换。

public class Test {

    //交换array1数组和array2的内容
    public static void change(int[] array1,int[] array2){
        for(int i=0;i<array1.length;i++){
            int temp=array1[i];
            array1[i]=array2[i];
            array2[i]=temp;
        }
    }

    //交换变量a与b的内容
    public static void change(int a,int b){
        int temp=a;
        a=b;
        b=temp;
    }

    //获得字符串中的所有字符
    public static char[] getChars(String str){
        if(str.length()==0)
            return new char[0];
        char[] c=new char[str.length()];
        for(int i=0;i<str.length();i++)
            c[i]=str.charAt(i);
        return c;       
    }

    public static void main(String[] args){
        int[] array1={1,3,5,7};
        int[] array2={2,4,6,8};

        change(array1,array2);
        for(int i=0;i<array2.length;i++)
            System.out.print(array2[i]+"\t");
        System.out.println();
        for(int i=0;i<array1.length;i++)
            System.out.print(array1[i]+"\t");
        System.out.println();

        change(array1[1],array2[2]);
        System.out.println("array2[1]="+array2[1]);
        System.out.println("array2[2]="+array2[2]);

        char[] chars=getChars("Hello");
        for(int i=0;i<chars.length;i++)
            System.out.print(chars[i]);
    }
}

八、数组实用类：Arrays
java.util.Arrays类提供了一系列操作数组的静态方法:
（1）equals():比较两个数组是否相同。只有两个数组元素数目、对应位置元素都相同时，两个数组才相同。
（2）fill()：向数组中填充数据。
（3）sort():把数组中元素按升序排列。
（4）binarySearch():该方法只能针对已经升序排列的数组，实现查找数组中值与给定数据相同的元素。
（5）toString():返回包含数组中所有元素信息的字符串。