概览

主要集合类

list

list是一种有序的集合，其允许重复元素，主要实现有三种，分别如下所示

ArrayList

是以数组实现的list，类似思想可以参考数据结构的数组，其方便按照索引检索，但是插入和删除都比较耗时。不同于Java数组的是其容量大小可以动态调整，ArrayList在元素填满时，会自动扩充容器大小的50%。其初始化只能使用引用数据类型。
主要方法：add();set();get();remove();size()

public static void main(String[] a) {
        ArrayList<Integer> al = new ArrayList();
        al.add(3);
        al.add(2);
        al.add(1);
        al.add(4);
        al.add(5);
        al.add(6);
        al.add(new Integer(6));
        System.out.print("The third element is  ");
        System.out.println(al.get(3));
        al.remove(3);
        //(index:3,element:9)
        al.add(3, 9);
    }
    //适合随机索引值遍历
    public static void traverseByIndex(ArrayList<Integer> al) {
        for(int i = 0; i < al.size(); ++i) {
            al.get(i);
        }
    }

LinkedList

是以双向链表实现的list集合，对于插入和删除都比较高效，但是按位置检索比较效率低。也就是顺序访问高效，随机访问较差，适合变动较大的数据。创建方法和使用与ArrayList类似，但是对于其遍历一般使用迭代器遍历或者foreach循环。
函数方法和ArrayList类似

public static void traverseByIterator(LinkedList<Integer> list) {
        System.out.println("============迭代器遍历==============");
        Iterator iter1 = list.iterator();
        while(iter1.hasNext()) {
            iter1.next();
        }
    }
public static void traverseByFor(LinkedList<Integer> list) {
        System.out.println("============for循环遍历==============");
        for(Integer var3:list)
        {
        	;
        }
    }

Vector

Vector和ArrayList类似，但是不同点是它是同步的，适合在多线程下使用。

set

对于下面三种set而言，其元素只能是对象，就以HashSet而言，其声明必然是Hashet item = new Hashet();其中的ClassName也必须是对象类。
另外，对于set而言是不允许集合内数据重复的，所以了解下面三种不同的集合类判断元素重复的规则就是必要的。首先，对于HashSet和LinkedHashSet来说是利用hashCode值以及equals方法共同判断。对于TreeSet而言，则是利用继承自Comparable接口的compareTo方法来判断。

HashSet

基于散列函数的集合，可以容纳null元素，无序，不支持同步

import java.util.HashSet; // 引入 HashSet 类
public static void main(String[] args) {
		HashSet<Integer> hs = new HashSet<Integer>();
		hs.add(null);
		//重复元素不会被添加	
		Hs.add(null);
		Hs.add(50);
		hs.add(1000);
		hs.add(20);
		hs.add(3);
		hs.add(40000);
		hs.add(5000000);
		hs.add(3);                      //3 重复
		hs.add(null);                   //null重复
		System.out.println(hs.size());  //6
		System.out.println(Hs.size());
		if(!hs.contains(6))
		{
			hs.add(6);
		}
		System.out.println(hs.size());  //7
		hs.remove(4);
		System.out.println(hs.size());  //6
		System.out.println("============for循环遍历=============="); 
	    for(Integer item : hs)
	    {
	    	System.out.println(item);
	    }

LinkedHashSet

基于散列函数和双向链表的集合，可排序，通过一个双向链表维持插入顺序。不支持同步，可以容纳null元素

TreeSet

基于Tree的集合，可排序，不支持同步，不可以容纳null元素

map

Hashtable

(k-v）形式，k和v都不允许null
同步，多线程安全，
无序，适合数据量小

public static void main(String[] args) {
		Hashtable<Integer,String> ht =new  Hashtable<Integer,String>();
		//key和vaule都不允许为null
		ht.put(1000, "aaa");
		ht.put(2, "bbb");
		ht.put(30000, "ccc");
		System.out.println(ht.contains("aaa"));
		System.out.println(ht.containsValue("aaa"));
		System.out.println(ht.containsKey(30000));
		System.out.println(ht.get(30000));
		ht.put(30000, "ddd");  //更新覆盖ccc
		System.out.println(ht.get(30000));
		ht.remove(2);
		System.out.println("size: " + ht.size());
		ht.clear();
		System.out.println("size: " + ht.size());		
	}

HashMap

(k-v）形式，k和v都允许null，但是最多允许一条记录的键为 null
不同步，多线程不安全，
无序

// 引入 HashMap 类      
import java.util.HashMap;
public static void main(String[] args) {
		HashMap<Integer,String> hm =new  HashMap<Integer,String>();
		hm.put(1, null); 
		hm.put(null, "abc");  
		hm.put(1000, "aaa");
		hm.put(2, "bbb");
		hm.put(30000, "ccc");
		System.out.println(hm.containsValue("aaa"));
		System.out.println(hm.containsKey(30000));
		System.out.println(hm.get(30000));
		hm.put(30000, "ddd");  //更新覆盖ccc
		System.out.println(hm.get(30000));
		hm.remove(2);
		System.out.println("size: " + hm.size());
		hm.clear();
		System.out.println("size: " + hm.size());
	}