JAVA 复习(Think In Java, 4th) -- Arrays - part1

使用 Array

数组(Array) 是任意存取数据时，最有效率的数据存储方式；但是弱点就是数组的大小是固定的，不能改变。

在有 Generic 之前，其它 Container 将所有储存的数据当做 Object 耒処理；而数组则是将数据当特定的类耒処理。也就是说，如果类的処理／对应方式错误，则在其它 Pre-Generic 的 Container会抛出异常(Exception)，而在数组则会出现编译错误(Compiling Error)，这可使程序员提早发现问题所在。

一个数组可以储存 Primitive 类(如 int, boolean, double, float　等等)而一个 pre-generic container 便做不到。有了 Generics　以後，使用autoboxing技术 （相关文章），container 便可以和数组一样地去储存 Primitive类。

import java.util.*;

public class ArrayComparison {

    public static void main(String[] args)
    {
        Car[] carArray = new Car[5];
        for(int i =0; i< carArray.length;i++)
            carArray[i] = new Car();
        System.out.println(Arrays.toString(carArray));

        List<Car> carArrayList = new ArrayList<Car>();
        for(int i =0;i < 5; i++)
            carArrayList.add(new Car());

        System.out.println(carArrayList);
///

        int[] intArray = {1,2,3,4,5};
        System.out.println(Arrays.toString(intArray));

        //如果不加 generic（<Integer>）, 虽然可以编译通过，但是会产生以下警告
        //注: ArrayComparison.java使用了未经检查或不安全的操作。
        //注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。  
        List<Integer> intArrayList = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));

        System.out.println(intArrayList);
    }


}

class Car {
        private int count;
        private final int ID;
        public Car() {
            ID = count++;
        }

        public String toString() {
            return "Car ID"+ID;
        }
    }

数组和 Container（上例中为 List）储存和存取数据时，都会做类型检查(Type Checked)，主要的差别是 Container类会使用 add(), get() 等等的方法。当然，和数组相比，Container提供的功能较为丰富，而数组则是较有效率的数据存储処理方式。

不管你処理的是哪一种数组，数组所包涵的，就是指向 heap上相关资料的 Reference。

以下为数组的一些宣告方法：

import java.util.*;

public class ArrayDeclare {
    public static void main(String[] args) {
        // 一、针对 Object 类型的
        // Car的数组宣告:
        Car[] carArray1 = new Car[4];
        // 数组里的 Reference 一开始自动设为 null
        System.out.println("Array before init: "+Arrays.toString(carArray1));
        // 所以我们要对它进行初始化
        for(int i = 0; i< carArray1.length; i++)
            carArray1[i] = new Car();

        System.out.println("Array after init: "+Arrays.toString(carArray1));

        // Aggregate initialization:
        Car[] carArray2 = { new Car() , new Car() , new Car()};
        System.out.println("Array after aggregate init: "+Arrays.toString(carArray2));

        // Dynamic aggregate initialization:
        Car[] carArray3 = new Car[]{ new Car(),new Car() };
        System.out.println("Array after dynamic aggregate init: "+Arrays.toString(carArray3));


        // 针对 Primitive 类型的
        int[] intArray1 = new int[4];
        // 数组里的 Reference 一开始自动设为 0 
        System.out.println("Array before init: "+Arrays.toString(intArray1));
        // 初始化後
        for(int i=0; i< intArray1.length;i++)
            intArray1[i] = i;

        System.out.println("Array after init: "+Arrays.toString(intArray1));

        int[] intArray2 = { 4 , 5 ,6, };
        System.out.println("Array after aggregate init: "+Arrays.toString(intArray2));
    }

}

class Car {
    private static int count; // 这边用 static 关键字，可以做为统计 Car Object 有几个，没有 static　的话，则每次都是从 0算起
    private final int id = count++; // 我们不希望 Car 的 Id 被後面的人修改，所以就使用 final 这个关键字
    public String toString() {
        return "Car"+id;
    }

此外，如果有一个方法拿数组当参数，如

checkArray(carArray);

我们可以用另一种方式去做：

checkArray(new Car[]{new Car(), new Car(), new Car()});

写个例子如下：

public class practice {
    public static void main(String[] args)
    {
       System.out.println("Total Salary:"+ getTotalMoney(new people[]{new people(1000), new people(200)}));
    }

    private static int getTotalMoney(people[] ppl) {
        int total = 0;
        for(int i =0; i < ppl.length; i++)
        {
            total+=ppl[i].salary;
        }
        return total;
    }
}

class people {
   int salary;
   public people(int money) {
       salary = money;
   }

}

Returningan array

返回数组就像返回一个Object一样，其实都是返回一个引用(reference)，我们不用担心数组是在涵数内部创建的，或是其它地方创建的，因为最後一旦没有了引用，java的garbagecollector就会对该数据所占有的内存部份进行回收。下面是返回球物件数组的范例。主要是随机取一个数，然後取那麽多的球，假如超过五个球的话，则抛异常。

import java.util.*;

class practice {
    static final String[] colors = {
            "红", "蓝", "白", "黄", "黑"
    };

    public static void main(String[] args) {
        Random a = new Random();
        int gotNum;

        for (int i = 0; i < 5; i++) {
            gotNum = a.nextInt(8);

            System.out.println("get" + gotNum + " balls");
            try {
                ball[] selected = getRandomBalls(gotNum);
                declareBallColor(selected);
            } catch (Exception e) {
                System.out.println("oops,exception catched");
            }

        }

    }

    static void declareBallColor(ball[] balls) {
        for (int i = 0; i < balls.length; i++) {
            int j = i + 1;
            System.out.print("第" + j + "个球:" + balls[i].color + "。");
        }
        System.out.println();
    }

    static ball[] getRandomBalls(int num) {
        ball[] selected;

        if (num > colors.length)

            throw new IllegalArgumentException("the num is too large");

        else {

            selected = new ball[num];

            Random a = new Random();

            for (int i = 0; i < num; i++) {

                int gotBallColor = a.nextInt(colors.length);

                selected[i] = new ball(colors[gotBallColor]);
            }
        }

        return selected;
    }

}

class ball {

    String color;

    public ball(String clr) {
        color = clr;
    }

}