Step By Step(Java 集合篇)

    1.    Java集合类库中最重要的两个接口Collection<E>和Map<K,V>，其中Collection接口又再次划分为 List和Set两大子接口，List中可以包含重复的元素，Set中则不可以。以下列举出一些常用的集合实现类，他们均分别继承自这两个接口：
    1)    ArrayList: 一种可以动态增长和缩减的索引序列(动态数组，类似于C++中的vector)；
    2)    LinkedList: 一种可以在任何位置进行高效的插入和删除操作的有序序列(类似于C++中list)；
    3)    ArrayDeque: 一种用循环数组实现的双端队列(类似于C++中的deque)；
    4)    HastSet：一种没有重复元素的无序集合(C++的标准库中并未提供hashset集合，但是Windows的VC和Linux平台下的gcc均各自提供了hashset容器)；
    5)    TreeSet: 一种有序集(类似于C++中的set)；
    6)    EnumSet: 一种包含枚举类型值的集；
    7)    LinkedHashSet: 一种可以记住元素插入次序的集，在其内部由LinkedList负责维护插入的次序，HashSet来维护Hash；
    8)    HashMap：一种存储键值对关联的数据结构(C++的标准库中并未提供hashmap集合，但是Windows的VC和Linux平台下的gcc均各自提供了hashmap容器)；
    9)    TreeMap：一种键值有序排列的映射表(类似于C++中的map)；
    10)   EnumMap：一种键值属于枚举类型的映射表；
    11)   LinkedHashMap：一种可以记住键值项插入次序的映射表；
    2.    ArrayList：该集合的底层是通过动态数组来实现的，集合构造的时候可以指定一个初始容量，当插入的元素过多导致已有的容量不能容纳新元素是，其底 层数组的容量将自动增长原有容量的1.5 倍，这样会带来一定的空间浪费，但是为了避免经常扩张而带来的性能开销，只能是用空间换取时间了。如果在容器的中间添加或者删除一个元素都将会导致后面的 元素向后或向前移动一个位置，如果元素数量较多且该操作比较频繁，将会导致系统的性能降低，然而对于容器中元素的随机访问性能较好，以下为 ArrayList的常用示例代码：

    public static void showIterator() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Monday");
        list.add("Tuesdag");
        list.add("Wednesday");
        Iterator<String> iterator = null;
        iterator = list.iterator();
        //while
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
        //for
        for (iterator = list.iterator(); iterator.hasNext();) {
            String element = iterator.next();
            System.out.println(element);
        }
        //for each
        for (String element : list) {
            System.out.println(element);
        }
    }

    public static void showSetAndGet() {
        ArrayList<String> nums = new ArrayList<String>();
        nums.clear();
        nums.add("One");
        nums.add("Two");
        nums.add("Three");
        System.out.println(nums);
        nums.set(0, "Uno");
        nums.set(1, "Dos");
        nums.set(2, "Tres");
        for (int i = 0; i < nums.size(); ++i)
            System.out.println(nums.get(i));
    }
    
    public static void showRemoveAndSize() {
        ArrayList<String> al = new ArrayList<String>();
        System.out.println("Initial size of al: " + al.size());
        al.add("C");
        al.add("A");
        al.add("E");
        al.add("B");
        al.add(1, "A2");
        System.out.println("Size of al after additions: " + al.size());
        System.out.println("Contents of al: " + al);
        al.remove("F");
        al.remove(2);
        System.out.println("Size of al after deletions: " + al.size());
        System.out.println("Contents of al: " + al);
        Iterator<String> it = al.iterator();
        //Notes：remove() must be called after next()
        it.next();
        it.remove();
        System.out.println("Size of al after deletions: " + al.size());
        System.out.println("Contents of al: " + al);        
    }
    
    public static void showSubListAndCopyToArray() {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        List<String> lst = arrayList.subList(1, 3);
        for (int i = 0; i < lst.size(); i++)
            System.out.println(lst.get(i));        
        // remove one element from sub list
        String obj = lst.remove(0);
        System.out.println(obj + " is removed");
        for (String str: arrayList)
            System.out.println(str);
        //get object array with normal method
        Object[] objArray = arrayList.toArray();
        for (Object obj1 : objArray)
            System.out.println(obj1);
        //get object array with generic method
        String[] strArray = arrayList.toArray(new String[0]);
        for (String str : strArray)
            System.out.println(str); 
    }
    
    public static void showListIterator() {
        ArrayList<String> aList = new ArrayList<String>();
        aList.add("1");
        aList.add("2");
        aList.add("3");
        aList.add("4");
        aList.add("5");
        
        ListIterator<String> listIterator = aList.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
            System.out.println("Previous: " + listIterator.previousIndex());
            System.out.println("Next: " + listIterator.nextIndex());
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
            System.out.println("Previous: " + listIterator.previousIndex());
            System.out.println("Next: " + listIterator.nextIndex());
        }
        listIterator = aList.listIterator(2);
        listIterator.next();
        listIterator.set("100");
        listIterator.next();
        listIterator.remove();
        for (String str : aList)
            System.out.println(str);

        if (aList.contains("4"))
            System.out.println("True");
        else
            System.out.println("False");
    }
    
    public static void showFillAndReplace() {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("A");
        arrayList.add("C");
        arrayList.add("D");
        Collections.replaceAll(arrayList, "A", "Replace All");
        System.out.println(arrayList);
        Collections.fill(arrayList, "REPLACED");
        System.out.println(arrayList);
    }

    public static void showCollectionOperation() {
        List<String> colours = new ArrayList<String>();
        colours.add("red");
        colours.add("green");
        colours.add("blue");

        System.out.println(colours);
        Collections.swap(colours, 0, 2);
        System.out.println(colours);

        Collections.reverse(colours);
        System.out.println(colours);

        Collections.sort(colours);
        System.out.println(Arrays.toString(colours.toArray()));
        Collections.sort(colours, Collections.reverseOrder());
        System.out.println(Arrays.toString(colours.toArray()));

        int index = Collections.binarySearch(colours, "green");
        System.out.println("Element found at : " + index);
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(new Integer("3"));
        arrayList.add(new Integer("1"));
        arrayList.add(new Integer("8"));
        arrayList.add(new Integer("3"));
        arrayList.add(new Integer("5"));
        System.out.println(Collections.min(arrayList));
        System.out.println(Collections.max(arrayList));
    }
    
    public static void showMinMax() {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(new Integer("3"));
        arrayList.add(new Integer("1"));
        arrayList.add(new Integer("8"));
        arrayList.add(new Integer("3"));
        arrayList.add(new Integer("5"));
        System.out.println(Collections.min(arrayList));
        System.out.println(Collections.max(arrayList));
    }
    
    public static void showSynchronizedList() {
        ArrayList arrayList = new ArrayList();
        List list = Collections.synchronizedList(arrayList);
        //list之后的并发操作将不再需要synchronized关键字来进行同步了。
    }

    3.    LinkedList:    该集合是通过双向链表来实现的，对于指定位置元素的遍历其内部做了一个小的优化，如果position大于len/2，由于内部的数据结构是双向链表，因 此可以从后向前遍历，以减少遍历过程中节点跳转的次数。ArrayList中的大部分代码示例都适用于LinkedList，以下近给出 LinkedList特有的常用示例代码：

    public static void showNewFeatures(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("1");
        lList.add("2");
        lList.add("3");
        lList.add("4");
        lList.add("5");
        
        System.out.println("First element of LinkedList is : " + lList.getFirst());
        System.out.println("Last element of LinkedList is : " + lList.getLast());
        System.out.println(lList);
        
        String str = lList.removeFirst();
        System.out.println(str + " has been removed");
        System.out.println(lList);
        str = lList.removeLast();
        System.out.println(str + " has been removed");
        System.out.println(lList);
        
        lList.addFirst("1");
        System.out.println(lList);
        lList.addLast("5");
        System.out.println(lList);    
    }

    4.    ArrayList和LinkedList的相同点：
    1)    都是接口List<E>的实现类；
    2)    都可以通过iterator()方法返回Iterator<E>迭代器对象，并可以通过该对象遍历容器中的元素；
    3)    如果多个Iterator<E>实例同时引用同一个集合对象，那么当有一个正在遍历，而另外一个修改(add/remove)了集合对象中的 元素，对于第一个迭代器再进行迭代时将会引发ConcurrentModificationException异常的发生。
    5.    ArrayList和LinkedList的不同点：
    1)    对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一 项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。
    2)    在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
    3)    LinkedList不支持高效的随机元素访问。
    4)    ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
    在C++的标准库中，ArrayList和LinkedList之间的使用差异以及各自的优缺点也同样反映于vector和list。
    6.    HashSet: 散列表为每个对象计算出一个整数(通过Object缺省的或类重载的hashCode域方法)，称为散列码。在Java中，散列表是使用链表的数组来实现 的，每个链表被称为一个哈希桶。如果想在哈希表中查找一个对象，则需要先计算对象的hashCode，之后对表内的桶数取余数，得到的结果就是哈希桶的索 引，此时如果该桶为空桶，就可以直接将该对象插入到该桶中，如果已经有对象存在了，则需要逐个进行比较，一旦发现该与该对象相等的对象(equals() 返回true)，就会放弃本次插入操作，否则将该对象插入到该桶的末端。HashSet在构造的时候提供两个参数，一个是initialCapacity 指定了桶的数量(实际的桶数为2的initialCapacity次幂)，另一个是loadFactortian(0.0--1.0,推荐值为 0.75)，当桶的填充百分比达到该值后，哈希表内的哈希桶数将double，重新填充已有对象，该操作被称为rehash，rehash是十分影响效率 的操作，因为为了尽可能避免该事件的发生，因可能在构造HashSet的时候给出一个合理的参数。以下为HashSet的常用示例代码：

    public static void showAddAndIterator() {
        HashSet<String> hs = new HashSet<String>();
        hs.add("B");
        hs.add("A");
        hs.add("D");
        hs.add("E");
        hs.add("C");
        hs.add("F");
        System.out.println(hs);
        Iterator<String> it = hs.iterator();
        while (it.hasNext())
            System.out.println(it.next());
    }
    public static void showRemoveAndClearAndContains() {
        HashSet<Integer> hSet = new HashSet<Integer>();
        hSet.add(new Integer("1"));
        hSet.add(new Integer("2"));
        hSet.add(new Integer("3"));
        System.out.println(hSet.contains(new Integer("3")));
        System.out.println(hSet);
        boolean blnRemoved = hSet.remove(new Integer("2"));
        System.out.println(hSet.contains(new Integer("2")));
        System.out.println(blnRemoved);
        System.out.println(hSet);    
        hSet.clear();
        System.out.println(hSet);
        System.out.println(hSet.isEmpty());
    }
    
    public static void showToArrayListAndArray() {
        HashSet<String> hs = new HashSet<String>();
        hs.add("B");
        hs.add("A");
        hs.add("D");
        System.out.println(hs);
        List<String> list = new ArrayList<String>(hs);
        Object[] objects = list.toArray();
        for (Object obj : objects)
            System.out.println("Object = " + obj);
        String[] strs = list.toArray(new String[0]);
        for (String str : strs)
            System.out.println("String = " + str);
    }

    public static void showToHashSetAndRemoveDuplicate() {
        Integer[] numbers = { 7, 7, 8, 9, 10, 8, 8, 9, 6, 5, 4 };
        List<Integer> list = Arrays.asList(numbers);
        Set<Integer> set = new HashSet<Integer>(list);
        for (Integer o : set)
            System.out.print(o + ", ");
    }
    
    public static void showMinMax() {
        HashSet<Long> hashSet = new HashSet<Long>();
        hashSet.add(new Long("9"));
        hashSet.add(new Long("4"));
        hashSet.add(new Long("2"));
        hashSet.add(new Long("2"));
        hashSet.add(new Long("3"));
        Object objMin = Collections.min(hashSet);
        System.out.println("Minimum Element of Java HashSet is : " + objMin);
        Object objMax = Collections.max(hashSet);
        System.out.println("Maximum Element of Java HashSet is : "+ objMax);
    }

    public static void showSynchronizedSet() {
        HashSet hashSet = new HashSet();
        Set set = Collections.synchronizedSet(hashSet);
        //set之后的并发操作将不再需要synchronized关键字来进行同步了。
    }

    7.    TreeSet：该集合为有序集合，数据在插入集合后便按照自定义的排序规则将插入的对象进行排序，该集合主要是通过两种方式排序插入对象的，一种是要求 集合元素类必须是Comparable<T>的实现类，这样在插入对象的时候，集合可以根据compareTo方法的返回值来确定新插入对象 的位置，另外一种方式是通过在构造该集合对象的时候，传入Comparator<T>的实现类作为参数，之后所有插入的对象都是通过 Comparator<T>的compare方法的返回值来决定新对象的位置。该集合是通过RBTree(红黑树)来实现排序的，这一点和 C++标准库中的set和map是一致的。由于对象插入集合之后是有序的，因此该集合的插入效率要低于HashSet的插入效率。TreeSet和 HashSet相比主要的差异来自于对象的排序规则，以上HashSet的示例代码均适用于TreeSet，下面只是列出对象比较的代码：

    public class Item implements Comparable<Item> {
        public int compareTo(Item other) {
            return partNumber - other.partNumber;
        }
    }
    public static void main(String[] args) {
        SortedSet<Item> parts = new TreeSet<Item>();
        parts.add(new Item("Toaster",1234));
        parts.add(new Item("Widget",4562));
        parts.add(new Item("Modem",9912));
        System.out.println(parts);
        
        SortedSet<Item> sortByDescription = new TreeSet<Item>(new Comparator<Item>() {
            public int compare(Item a,Item b) {
                String descA = a.getDescription();
                String descB = b.getDescription();
                return descA.compareTo(descB);
            }
        });
        sortByDescription.addAll(parts);
        System.out.println(sortByDescription);
    }

    8.    PriorityQueue(优先级对象): 该容器也是有序集合，和TreeSet不同的是，该集合只是保证当从集合的头部取出数据的时候，总是取出队列中最小(优先级最高)的元素。该集合内部是通 过"堆"的数据结构实现的，该结构只有第一个元素(头部元素)保证为该集合中最大的或最小的元素，其余元素没有固定的顺序，但是当集合有新的对象从尾部插 入或是从头部取出时，集合内部的相关元素会进行比较的比较最终再次决定出谁是最大或最小的元素作为头部元素。在JDK提供的classes中Timer是 通过该数据结构实现的，从而保证了Timer每次获取任务时都是最应该被调度的TimerTask，见如下代码：

    public class TestMain {
        public static void main(String[] args) {
            PriorityQueue<String> pq = new PriorityQueue<String>();
            pq.add("1");
            pq.add("6");
            pq.add("4");
            pq.offer("5");
            pq.offer("3");
            pq.offer("2");
            pq.offer("7");
            //以下输出将以无序的结果输出
            System.out.println(pq);
            //以下输出将以有序的结果输出
            while (pq.peek() != null) {
                String str = pq.poll();
                System.out.println(str);
            }
            int initCapacity = 20;
            PriorityQueue<TestComparator> pq1 = new PriorityQueue<TestComparator>(initCapacity,
                new Comparator<TestComparator>() {
                    public int compare(TestComparator t1, TestComparator t2) {
                        return t1.getID() - t2.getID();
                    }
                });
            pq1.offer(new TestComparator(1));
            pq1.offer(new TestComparator(6));
            pq1.offer(new TestComparator(4));
            pq1.offer(new TestComparator(5));
            pq1.offer(new TestComparator(3));
            pq1.offer(new TestComparator(2));
            pq1.offer(new TestComparator(7));
            System.out.println("The following is for TestComparator.");
            System.out.println(pq1);
            while (pq1.peek() != null) {
                int id = pq1.poll().getID();
                System.out.println(id);
            }
        }
    }
    
    class TestComparator {
        public TestComparator(int id) {
            _id = id;
        }
        public int getID() {
            return _id;
        }
        public String toString() {
            return Integer.toString(_id);
        }
        private int _id;
    }

    9.    HashMap：其内部数据结构的逻辑类似于HashSet，只是Map存储的都是key/value的键值映射关系，key相当于HashSet中的对 象，value只是附着于key的对象，使用者一般都是通过key的值去HashMap中搜索，找到并返回该key以及相关联的value，其内部实现机 制可参考HashSet。在接口方面主要的不同点是Map对象可以生成3个集合的视图(仅仅是视图，没有对象copy，视图的底层容器仍然来自于原映射对 象集合，如果在其中任意视图或原集合删除和添加数据都会及时反应与其他视图和映射集合)。该规则同样适用于TreeMap。见以下常用代码示例：

    public static void showGetAndPut() {
        HashMap<String, Double> hm = new HashMap<String, Double>();
        hm.put("A", new Double(3.34));
        hm.put("B", new Double(1.22));
        hm.put("C", new Double(1.00));
        hm.put("D", new Double(9.22));
        hm.put("E", new Double(-19.08));
        //随机的获取HashMap中的数据
        Set<Map.Entry<String, Double>> set = hm.entrySet();
        for (Map.Entry<String, Double> me : set) {
            System.out.print(me.getKey() + ": ");
            System.out.println(me.getValue());
        }
        double balance = hm.get("A");
        //输出1003.34
        hm.put("A", balance + 1000);
        System.out.println(hm.get("A"));
    }
    
    public static void showContainsAndRemove() {
        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("1", "One");
        hashMap.put("2", "Two");
        hashMap.put("3", "Three");
        System.out.println(hashMap.containsValue("Three"));
        String str = hashMap.remove("2");
        System.out.println("old value of 2 = " + str);
        System.out.println(hashMap.containsValue("Two"));
        Set<String> st = hashMap.keySet();
        st.remove("1");
        System.out.println("The size is equal to " + hashMap.size());
        System.out.println(hashMap.containsKey("3"));
    }
    /* 结果如下
        true
        old value of 2 = Two
        false 
        The size is equal to 1 
        true */
        
    public static void showIterator() {
        String names[] = { "Mercury", "Venus", "Earth", "Mars", "Jupiter"
            , "Saturn", "Uranus", "Neptune", "Pluto" };
        float diameters[] = { 4800f, 12103.6f, 12756.3f, 6794f, 142984f
            , 120536f, 51118f, 49532f, 2274f };
        Map<String,Float> map = new HashMap<String,Float>();
        for (int i = 0, n = names.length; i < n; i++)
            map.put(names[i], new Float(diameters[i]));
        Iterator<String> it = map.keySet().iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str + ": " + map.get(str));
        }
    }

    public static void showSynchronizedMap() {
        TreeMap<String,String> treeMap = new TreeMap<String,String>();
        Map<String,String> map = Collections.synchronizedMap(treeMap);
        //Map之后的并发操作将不再需要synchronized关键字来进行同步了。
    }

      10.    TreeMap：TreeMap和TreeSet之间的相似性和主要差异就像HashMap之于HashSet，见以下常用代码示例：

    public static void showSubMapAndHeadMapAndTailMap() {
        TreeMap<String, String> sortedMap = new TreeMap<String, String>();
        sortedMap.put("Adobe", "Mountain View, CA");
        sortedMap.put("IBM", "White Plains, NY");
        sortedMap.put("Learning Tree", "Los Angeles, CA");
        sortedMap.put("Microsoft", "Redmond, WA");
        sortedMap.put("Netscape", "Mountain View, CA");
        sortedMap.put("O'Reilly", "Sebastopol, CA");
        sortedMap.put("Sun", "Mountain View, CA");
        System.out.println(sortedMap);
        //firstKey and lastKey 是SortedMap中提供的方法，HashMap中没有。
        String low = sortedMap.firstKey(), high = sortedMap.lastKey();
        System.out.println(low);
        System.out.println(high);
        Iterator<String> it = sortedMap.keySet().iterator();
        int i = 0;
        while (it.hasNext()) {
            if (i == 3)
                low = it.next();
            if (i == 6)
                high = it.next();
            else
                it.next();
            i++;
        }
        System.out.println(low);
        System.out.println(high);
        //以下3个方法也是SortedMap中提供的方法，HashMap中没有。
        System.out.println(sortedMap.subMap(low, high));
        System.out.println(sortedMap.headMap(high));
        System.out.println(sortedMap.tailMap(low));
    }

    11.    LinkedHashSet和LinkedHashMap：这两个集合与HashSet和HashMap唯一的差异是LinkedHashSet和LinkedHashMap通过内部实现的双向链表保留了集合元素的插入顺序，见如下代码：

    public static void main(String[] a) {
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("1", "value1");
        map.put("2", "value2");
        map.put("3", "value3");
        map.put("2", "value4");
        for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) {
            String key = it.next();
            String value = map.get(key);
            System.out.println(value);
        }
    }
    /* 结果如下：
        value1
        value4
        value3 */

    //基于Values的排序后输出Keys
    public static void main(String[] a) {
        Map<String, String> yourMap = new HashMap<String, String>();
        yourMap.put("1", "one");
        yourMap.put("2", "two");
        yourMap.put("3", "three");

        Map<String, String> map = new LinkedHashMap<String, String>();
        List<String> keyList = new ArrayList<String>(yourMap.keySet());
        List<String> valueList = new ArrayList<String>(yourMap.values());
        Set<String> sortedSet = new TreeSet<String>(valueList);
        String[] sortedArray = sortedSet.toArray(new String[0]);
        int size = sortedArray.length;

        for (int i = 0; i < size; i++)
            map.put(keyList.get(valueList.indexOf(sortedArray[i])), sortedArray[i]);

        Set<String> ref = map.keySet();
        Iterator<String> it = ref.iterator();
        while (it.hasNext()) {
            String i = (String) it.next();
            System.out.println(i);
        }
    }    

    12.    EnumSet和EnumMap，这两个集合可以看做是类型参数特化后的Set<E extends Enum<E>>和Map<E extends Enum<E>,V>，EnumSet没有显示的构造函数，而是通过一组工厂方法来创建了，见如下代码：

    enum Weekdays {
        Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
    }
    public static void main(String[] a) {
        EnumSet<Weekdays> es1 = EnumSet.allOf(Weekdays.class);
        EnumSet<Weekdays> es2 = EnumSet.noneOf(Weekdays.class);
        EnumSet<Weekdays> es3 = EnumSet.range(Weekdays.Thursday, Weekdays.Sunday);
        EnumSet<Weekdays> es4 = EnumSet.of(Weekdays.Monday,Weekdays.Saturday);
        System.out.println("es1 = " + es1);
        System.out.println("es2 = " + es2);
        System.out.println("es3 = " + es3);
        System.out.println("es4 = " + es4);
    }
    /* 结果如下：
        es1 = [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
        es2 = []
        es3 = [Thursday, Friday, Saturday, Sunday]
        es4 = [Monday, Saturday] */

    13.    集合视图：顾名思义，所有的集合视图和数据库中的普通视图一样，并不存储真实是的容器元素，而只是建立一套针对原有底层集合数据的引用机制，针对所有视图 的操作或底层集合的操作都会同时相互影响，如插入和删除等，但是对于视图而言，插入操作如果作用于其范围之外将会引发异常。对于不同类别的视图其操作也存 在不同的限制。
    1).    subList：获取底层集合中某一范围的元素，如List group2 = staff.asList(10,20); 这第一个索引上的数据是被包含的，第二个索引的数据是不被包含的。如果执行了group2.clear()操作情况了视图中的数据，那么staff中这段 范围内的数据也会被连同删除。对于有序集合和映射表(Map)，可以使用排序顺序而不是元素位置建立子范围，如SortedSet接口声明的 SortedSet<E> subSet(E from,E to); SortedSet<E> headSet(E to); SortedSet<E> tailSet(E from); 注意这3个参数的类型均不是元素的索引，而是对象本身。SortedMap中也有类似的方法，如SortedMap<K,V> subMap(K from,K to); SortedMap<K,V> headMap(K to); SortedMap<K> tailMap(K from)。在NavigableSet中提供更为丰富的接口，如NavigableSet<E> subSet(E from,boolean fromInclusive,E to,boolean toInclusive); NavigableSet<E> headSet(E to,boolean toInclusive); NavigableSet<E> tailSet(E from,boolean fromInclusive);
    2).    不可修改的视图：       
    Collections.unModifiableCollection();
    Collections.unModifiableList();        //用于ArrayList、LinkedList
    Collections.unModifiableSet();        //用于HashSet、TreeSet、LinkedHashSet
    Collections.unModifiableSortedSet();//用于TreeSet
    Collections.unModifiableMap();        //用于HashMap、TreeMap、LinkedHashMap
    Collections.unModifiableSortedMap();//用于TreeMap
    如List<String> staff = new LinkedList<String>(); List<String> unmodifiableList = new Collections.unmodifiableList(staff); 这里unmodifiableList作为一个List对象，所有访问器的方法均可像普通List一样操作，但是对于更改器方法的调用将会引发 UnsupportedOperationException异常。如果确实需要修改数据只能通过原始集合来完成。
    3)    同步视图：
    Collections.synchronizedList();        //用于ArrayList、LinkedList
    Collections.synchronizedSet();        //用于HashSet、TreeSet、LinkedHashSet
    Collections.synchronizedSortedMap();//用于TreeMap
    Collections.synchronizedSortedSet();//用于TreeSet
    Collections.synchronizedMap();        //用于HashMap、TreeMap、LinkedHashMap
    之后所有通过同步视图访问底层集合的操作都将是线程安全的，即synchronized关键字就不需要在集合的外部添加了，但是对于底层集合的直接访问仍然是线程不安全。
    4)    被检查视图：见以下两种情况，第一种情况将会在集合执行(String)rawList.get()操作时抛出ClassCastException异 常，第一种情况则会在rawList.add()操作时就立即抛出ClassCastException。

    public void uncheckedListTest() {
        ArrayList<String> strings = new ArrayList<String>();
        ArrayList rawList = strings;
        rawList.add(new Date()); //no exception is raised here.
        String ss = (String)rawList.get(0); //exception will be thrown here.
    }

    public void checkedListTest() {
        ArrayList<String> strings = new ArrayList<String>();
        ArrayList<String> safeStrings = Collections.checkedList(strings,String.class);
        ArrayList rawList = safeStrings;
        rawList.add(new Date()); //exception will be thrown here.
    }

    注：从集合框架的整体设计技巧、扩展性、效率等方面综合比较，Java在此方面和C++的stl相比还是存在一定的差距。特别是扩展性和效率方面，C++ 的标准库定义了更多更灵活的模参扩展。由于标准库都是通过模板的方式实现的，因此其执行效率要明显优于基于虚函数的虚指针和虚表的这种动态绑定的多态方 式，其不足只是编译速度稍微慢罢了。
    14.    算法：
    在C++中提供了一套泛型算法，主要涵盖排序、搜索和比较等通用操作，由于这些泛型算法完全基于各种集合提供的迭代器(iterator)统一接口，因此可以达到一种高度的泛型操作，以及算法函数和集合之间的完全松耦合。见如下C++代码：

    #include <algorithm>
    #include <set>
    #include <vector>
    using namespace std;
    int main()
    {
        vector<int> v1;
        for (int i = 0; i < 10; ++i)
            v1.push_back(i);
        set<int> s1;
        for (int i = 0; i < 20; ++i)
            s1.insert(i);
        sort(v1.begin(),v1.end());
        binary_search(v1.begin(),v1.end(),5);
        binary_search(s1.begin(),s1.end(),5);
        return 0;
    }

    在Java中同样提供了这样的泛型算法，不同的是这些算法函数都是Collections中静态方法。见如下Java代码：

    public static void main(String[] args) {
        List<Integer> v1 = new ArrayList<Integer>();
        for (int i = 0; i < 10; ++i)
            v1.add(i);
        
        List<Integer> l1 = new LinkedList<Integer>();
        for (int i = 0; i < 20; ++i)
            l1.add(i);
        
        Collections.sort(v1);
        Collections.sort(l1);
        Collections.binarySearch(v1, 5);
        Collections.binarySearch(l1, 5);
    }