JAVA 复习(Think In Java, 4th)-- Holding Your Object

有时我们会看到像这样的代码

List<Robot> robotList = new ArrayList<Robot>();

主要原因，是因为这样便於改变实现接口的方式，比如说 ArrayList 我们不要用了，要换成 LinkedList

List<Robot> robotList = new LinkedList<Robot>();

这时只要修改实现方式的地方即可。因为其它地方都是使用接口 API调的，而接口 List 的 API 都是 ArrayList 及 LinkedList所拥有的，所以不会影响外面的调用。

一次添加多个对象

import java.util.*;
public class Adding {
    public static void main(String[] args) {
        Collection<Integer> ci = new ArrayList<Integer>();
        for(int i = 0; i < 5; i++) {
            ci.add(i);
        }
        ci.addAll(Arrays.asList(1,2,3,4,5));

        Collections.addAll(ci, 1,2,3,4,5);
        printCollection(ci);
    }

    private static void printCollection(Collection<Integer> c) {
        for(Integer a: c) {
            System.out.println(a);
        }
        System.out.println("=============================");
    }
}

同时，使用 Arrays.asList() 方法所取得的 ArrayList 对象不可以再用 add( )方法，因为其 Array 的大小是固定的，如下：

import java.util.*;
public class Adding {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        list.add(6);
        printCollection(list);
    }

    private static void printCollection(Collection<Integer> c) {
        for(Integer a: c) {
            System.out.println(a);
        }
        System.out.println("=============================");
    }
}

如上图，这样便会出现 Runtime Exception

Set

HashSet 是所有的 Set 种类中，搜寻其拥有对象最快的，但对象存放的顺序按其规则； LinkedHashSet存放的顺序按原本对象加入的顺序；而 TreeSet 里的对象是经过排序的。

Map

HashMap 和 HashSet 一样，搜寻对象的速度是最快的；TreeMap 是有顺序的存放对象；而 LinkedHashMap 搜寻速度和 HashMap一样，但是所存放的对象是按加入的顺序去存放的。

List

有二种 List 一种是 ArrayList，强项在於随机存取所拥有对象的速度，而在新增及移除 ArrayList 中间的对象，其效率就不怎麽高；而另一种 LinkedList, 优化的有序存取，对LinkedList
中间的对象做新增和移除时，成本不高，但弱项在於随机存取。

Iterator

当你不知该用 Set或 List来实现时数据结构，或中途有可能改变实现方式时， Iterator便是你的好选择，Iterator又称为轻量的对象(Lightweight Object)，使用的成本低，同时， Iterator可无视对象群所在的数据结构实现方式而遍历过一群对象，

import java.util.*;
public class Adding {
    public static void main(String[] args) {
        Collection<Integer> ci = new ArrayList<Integer>();
        ci.addAll(Arrays.asList(1,2,3,4,5));
        List<Integer> list = Arrays.asList(1,2,3,4,5);

        Iterator<Integer> it = list.iterator();
        Integer curValue;
        while(it.hasNext()) {
            curValue = it.next();
            System.out.println(curValue);
        }
    }
}

foreach 和 Iterator

我们常用 foreach 的方式遍历数组，但是我们同时也可以用 foreach 去遍历 ArrayList 等 Collection的子类 class，那是因为 Collection 继承了
Iterable 接口，因此，只要我们的类是继承或是实现了 Iterable 接口，那我们的类也能被 foreach 遍历了，如下：

import java.util.Iterator;

public class holdIterable implements Iterable<String> {
    private String[] mStrArray = "I am a fighter, and nothing will change that!".split(" ");

    @Override
    public Iterator<String> iterator() {
        return new Iterator<String>() {
            private int mIndex = 0;

            @Override
            public boolean hasNext() {
                return mIndex < mStrArray.length;
            }

            @Override
            public String next() {
                return mStrArray[mIndex++];
            }

            @Override
            public void remove() {
                System.out.println("not support remove function");
            }
        };
    }

    public static void main(String[] args) {
        for(String str: new holdIterable()) {
            System.out.println(str);
        }
    }
}

要注意的是，foreach 虽然可以遍历数组及 Iterable接口实现／继承类（Map不是，所以不能用 foreach 遍历），但是数组并不是 Iterable，我们可用下面的代码去测试：

import java.util.*;

public class ArrayIsNotIterable {
    public static<T> void test(Iterable<T> ib) {
        for(T t: ib) {
            System.out.println(t + "");
        }
    }

    public static void main(String[] args) {
        test(Arrays.asList(1,2,3));
        String[] strings = {"A","B","C"};
        // test(strings); --> 编绎错误
        for(String a: strings) {
            System.out.println(a);
        }
    }
}

test(strings); 若编绎的话，因为数组不是 Iterable 则会产生编绎错误如下：