Java 集合

参考文章： http://www.cnblogs.com/xingele0917/p/3695636.html

1. 集合框架

      

                    Collection                                                                                                                         Map

2. 集合比较

接口	实现类	保持插入顺序	可重复	排序	使用说明
List	ArrayList	Y	Y	N	长于随机访问元素；但插入、删除元素较慢（数组特性）。
	LinkedList	Y	Y	N	插入、删除元素较快，但随即访问较慢（链表特性）。
Set	HashSet	N	N	N	使用散列，最快的获取元素方法。
	TreeSet	N	N	Y	将元素存储在红-黑树数据结构中。默认为升序。
	LinkedHashSet	Y	N	N	使用散列，同时使用链表来维护元素的插入顺序。
Map	HashMap	N	N	N	使用散列，提供最快的查找技术。
	TreeMap	N	N	Y	默认按照比较结果的升序保存键。
	LinkedHashMap	Y	N	N	按照插入顺序保存键，同时使用散列提高查找速度。

      总结：

1） 如果要求线程安全，使用Vector，Hashtable
2） 如果不要求线程安全，使用ArrayList，LinkedList，HashMap
3)   如果要求键值对，则使用HashMap，Hashtable
4） 如果数据量很大，又要求线程安全考虑Vector
5） 新程序中不应该使用过时的Vector, Hashtable, Stack

1．ArrayList:    效率高，多用于查询
2．Vector:        线程安全，多用于查询
3．LinkedList:   多用于插入和删除
4．HashMap:    元素成对，元素可为空
5．HashTable:  元素成对，线程安全，元素不可为空

 

3.1 List

　　list中的大部分函数如indexOf和remove，使用equals方法判断两个对象是否为同一个对象。两个new出来的对象不是同一对象。

LinkedList也可以作为栈使用

操作	函数	列表为空
返回第一个元素	getFirst, element()	报错NoSuchElementException
	peek()	返回null
移除并返回第一个元素	removeFirst(), remove()	报错NoSuchElementException
	poll()	返回null
移除并返回最后一个元素	removeLast()
在列表尾部插入元素	add(), linkLast(), addLast()

3.2. Set

　　不保存重复的元素，常被用于查询某个对象是否在某个Set中，查找成了Set中最重要的操作。

判断一个数组是否包含重复数字

3.3 Stack

　   "先进后出"（LIFO）的容器

　　push(), pop(), peak()不删除头元素

3.4 Queue

"先进先出"（FIFO）的容器，元素放入容器和取出的顺序是一样的，队列常被当做一种可靠的将对象从程序的某个区域传输到另一个区域的途径。队列在并发编程中特别重要。

LinkedList提供了方法以支持队列的行为，并且它实现了Queue接口。

PriorityQueue

优先级队列声明下一个弹出的元素具有最高的优先级。PriorityQueue在使用offer()插入对象时会进行排序，像Integer 和 String 类型直接按升序比较值的大小，其他自定义类需要提供Comparator声明排序方式。

 

 

3.5 Map

　　Map可以使用entrySet() 和 values() 方法来产生Collection

 

3.6 迭代器

Iterator（单向迭代器）Collection集合可以使用迭代器，但数组和Map不行。

public class Test {

    public static void main(String[] args) {
        // 迭代器不关系容器的类型，能够将遍历序列的操作与序列底层的结构分离，该函数并不知道Iterator对应的容器类型
        ArrayList<String> list = new ArrayList<String>(Arrays.asList("1", "2", "3", "3"));
        HashSet<String> set = new HashSet<String>(list);
        System.out.println("
ArrayList使用迭代器：");
        print(list.iterator());
        System.out.println("
HashSet使用迭代器：");
        print(set.iterator());
        
        System.out.println("
对象持有者直接生成iterator方法:");
        print(new Person01().iterator());
        System.out.println("
对象持有者实现Iterable接口:");
        print(new Person02());
        
        System.out.println("
Map使用迭代器:");
        print(System.getenv());
    }
    
    public static void print(Iterator<String> it) { 
        while(it.hasNext()){
            System.out.print(it.next() + " ");
            it.remove();  // remove()之前必须先调用next(), 表示移除next()产生的最后一个元素
        }
    }

    public static void print(Iterable<String> c) { 
        for(String s : c){
            System.out.print(s + " ");
        }
    }
    
    public static void print(Map<String, String> map){
        for(Map.Entry entry : map.entrySet())  // 该set是一个Iterable
            System.out.print(entry.getKey() + ": " + entry.getValue() + ", ");
    }
}

class Person01 {
    String [] names = {"a","b","c"};
    
    public Iterator<String> iterator() {
        return new Iterator<String>(){
            private int index = 0;
            @Override
            public boolean hasNext() {
                return index < names.length;
            }
            @Override
            public String next() {
                return names[index++];
            }
            @Override
            public void remove() {
            }
        };
    }
}

class Person02 extends Person01 implements Iterable<String> {
}

 

运行结果：

ArrayList使用迭代器：
1 2 3 3
HashSet使用迭代器：
1 2 3
对象持有者直接生成iterator方法:
a b c
对象持有者实现Iterable接口:
a b c
Map使用迭代器:
PROCESSOR_LEVEL: 6, FP_NO_HOST_CHECK: ...

ListIterator（双向迭代器）