一. Set集合

1.HashSet集合，LinkedHashSet集合

@Test
public void test01() {
    //基本重複標準:equal()返回true
    Set<String> set;
    //根據hashCode()判斷重複及排序
    HashSet<String> hashset = new HashSet<String>();
    //根據hashCode()判斷重複,根據插入順序排序
    LinkedHashSet linkedHashset = new LinkedHashSet<String
 
>();

    hashset.add("b");
    hashset.add("a");
    hashset.remove("c");
    Iterator<String> t = hashset.iterator();
    while(t.hasNext()) {
        System.out.println(t.next());
    }
}

2.TreeSet集合

@Test
public void test02() {
    //根據compareTo()判斷重複及排序
    //自然排序:元素物件實現Comparable介面,重寫compareTo()
 

    TreeSet<Integer> treeSet = new TreeSet<Integer>();
    //定製排序:實現Comparator介面,作為建立集合的引數
    TreeSet<Entity> treeSet2 = new TreeSet<Entity>(new Comparator<Entity>(){
        @Override
        public int compare(Entity o1, Entity o2) {
            int subNum = o1.num-o2.num;
            return
 
 subNum;
        }
    });
    treeSet2.add(new Entity(1));
    treeSet.add(1);
    treeSet.add(2);
    //第一個元素
    treeSet.first();
    //最後一個元素
    treeSet.last();
    //元素小於2的子集
    treeSet.headSet(2);
    //元素大於等於2的子集
    treeSet.tailSet(2);
    //元素大於等於1,小於2的子集
    treeSet.subSet(1, 2);
}

public class Entity {
    public int num;
    public Entity(int num) {
        this.num = num;
    }
}

3.EnumSet集合

public void test03() {
    //只能存放指定的列舉物件，按在列舉中的順序排序
    //全部列舉值
    EnumSet es1 = EnumSet.allOf(Season.class);
    //空元素
    EnumSet es2 = EnumSet.noneOf(Season.class);
    //指定列舉值
    EnumSet es3 = EnumSet.of(Season.spring, Season.summer);
    //指定列舉值區間
    EnumSet es4 = EnumSet.range(Season.spring, Season.fall);
    //剩下的列舉值
    EnumSet es5 = EnumSet.complementOf(es4);

    es2.add(Season.summer);
    es1.removeAll(es2);
}

4.集合總結

1. 效能：EnumSet > HashSet = LinkedHashSet > TreeSet
2. 特點總結：
   (1)HashSet：新增，刪除操作
   (2)LinkedHashSet：遍歷
   (3)TreeSet：排序
   (4)EnumSet：列舉值
3. 四種集合都是執行緒不安全

二. List集合

1.ArrayList集合，Vector集合

@Test
public void test01() {
    //兩個集合功能相同
    ArrayList<String> box = new ArrayList<String>();
    Vector<String> vector = new Vector<String>();

    box.add("a");
    box.add(0,"b");
//  box.remove(1);
    box.set(0, "A");
    box.get(0);
    box.indexOf("A");
    List<String> subBox = box.subList(0, 1);
}

2.Stack集合

public void test02() {
    //增加了堆疊相關方法
    Stack<String> box = new Stack<String>();

    //在右端新增頂部元素,結果[a,b]
    box.push("a");
    box.add("b");
    //訪問頂部元素
    box.peek();
    //推出頂部元素
    box.pop();
}

3.LinkedList集合，ArrayDeque集合

@Test
public void test03() {
    //兩種集合方法一樣,都實現Deque介面(雙向佇列)
    LinkedList<String> box = new LinkedList<String>();
    ArrayDeque<String> deque = new ArrayDeque<String>();

    //在左端新增頂部元素,結果[c,b,a]
    box.push("a");
    box.offerFirst("b");
    box.addFirst("c");
    //新增底部元素,結果[c,b,a,d,e,f,g]
    box.offer("d");
    box.offerLast("e");
    box.add("f");
    box.addLast("g");   

    //訪問頂部元素
    box.peek();
    box.peekFirst();
    //訪問底部元素
    box.peekLast();

    //推出頂部元素
    box.pop();
    box.pollFirst();
    box.poll();
    //推出底部元素
    box.pollLast();
}

4.集合總結
(1) 實現方式：Vector，Stack，ArrayList，ArrayDeque採用陣列。LinkedList採用雙向連結串列。
(2) 執行緒安全：Vector，Stack安全。ArrayList，ArrayDeque，LinkedList不安全。
(3) 特點總結：Stack集合可以當棧。ArrayDeque集合，LinkedList集合可以當雙向佇列。
(4)時間複雜度：陣列集合查改遍歷效率高。連結串列集合增刪效率高。
(5)空間複雜度：陣列集合預留空間容量。連結串列集合元素本事消耗空間。
(6)遍歷方式：
(陣列集合)for>iterator>>foreach>>(連結串列集合)iterator>foreach>>>for

三.Map集合

1.HashMap集合，HashTable集合，LinkedHashMap集合

@Test
public void test01() {
    //根據equal()和hashCode()判斷key相等，根據hashCode排序
    HashMap<Integer,String> map = new HashMap<Integer,String>();
    //同上，執行緒安全，key和value不支援null
    Hashtable<String,String> table = new Hashtable<String,String>();
    //根據equal()和hashCode()判斷key相等，根據插入順序排序
    LinkedHashMap<Integer,String> map2 = new LinkedHashMap<Integer,String>();
    //複製所有鍵值對到map
    map.putAll(new HashMap());
    map.put(1,"a");
    map.put(null, null);
    //替換key對應的value
    map.replace(null, "b");
    //根據equals()和hashCode()判斷是否相同key
    map.containsKey(1);
    //根據equals()判斷是否含相同value
    map.containsValue("a");

    //遍歷集合
    for(Entry<Integer,String> entry :map.entrySet()) {
        entry.getValue();
        entry.getKey();
        entry.setValue("");
    }
    //遍歷集合
    for(Integer key : map.keySet()) {
        map.get(key);
    }
    map2.put(null,null);
}

2.TreeMap集合

@Test
public void test02() {
    //自然排序:key類要實現Comparable介面
    TreeMap<Bean, String> map = new TreeMap<Bean,String>();
    //定製排序:Comparator介面的物件作為集合的引數
    TreeMap<Bean, String> map2 = new TreeMap<Bean,String>(new Comparator<Bean>(){
        @Override
        public int compare(Bean o1, Bean o2) {
            return o1.count - o2.count;
        }
    });
    Bean b1 = new Bean(3);
    Bean b2 = new Bean(2);
    map.put(b1,"b1");
    map.put(b2, null);
    //獲取key的各種方法
    map.firstKey();
    map.lowerKey(b2);
    //獲取鍵值對的各種方法
    Entry<Bean, String> entry = map.lastEntry();
    entry = map.ceilingEntry(b1);
}

class Bean implements Comparable<Bean>{
    public int count;
    public Bean(int count) {
        this.count = count;
    }
    @Override
    public int compareTo(Bean bean) {
        return this.count-bean.count;
    }
}

3.WeakHashMap集合

@Test
public void test03() {
    //只儲存對key物件的弱引用，若物件被回收，鍵值對也會被清除
    WeakHashMap<String, Integer> map = new WeakHashMap<String,Integer>();
    map.put(null, null);
    map.put(new String("b"), 2);
    System.gc();
    //列印{null=null}
    System.out.println(map);
}

4.IdentityHashMap集合

@Test
public void test04() {
    //key為同一個物件才視為相等
    IdentityHashMap<Integer,String> map = new IdentityHashMap<Integer, String>();
    map.put(128, "a");
    map.put(128,"b");
    //列印{128=b, 128=a}
    System.out.println(map);
}

5.EnumMap集合

@Test
public void test05() {
    //key只能為列舉類
    EnumMap<Season, String> map = new EnumMap<Season, String>(Season.class);
    map.put(Season.spring, "春天")
}

四.集合列表