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 则会产生编绎错误如下：