map、set、list集合操作彙總

map類型對比

HashMap：遍歷時，獲取數據的順序完全隨機；不支持線程同步；
LinkedHashMap：可以保存記錄的插入順序，遍歷輸出的順序和插入的順序一致；
TreeMap：遍歷時，保存的記錄可以根據鍵自動排序；
HashTable：支持線程同步；不允許記錄的鍵或者值爲空；

public class mapTest {
    public static void main(String args[]){
        System.out.println("*************************LinkedHashMap*************");
        Map<Integer,String> map = new LinkedHashMap<Integer,String>();
        map.put(7, "阿里");
        map.put(9, "騰訊");
        map.put(6,"百度");
        for (Iterator it = map.keySet().iterator(); it.hasNext();)
        {
            Object key = it.next();
            System.out.println( key+"="+ map.get(key));
        }

        System.out.println("*************************HashMap*************");
        Map<String,String> map1 = new HashMap<String, String>();
        map1.put("7", "阿里");
        map1.put("9", "騰訊");
        map1.put("6", "百度");
        for(Iterator it1 =  map1.keySet().iterator();it1.hasNext();){
            Object key = it1.next();
            System.out.println(key+"="+map1.get(key));

        }

        System.out.println("*************************TreeMap*************");
        Map<Integer,String> map2 = new TreeMap<Integer, String>();
        map2.put(7, "阿里");
        map2.put(9, "騰訊");
        map2.put(6, "百度");
        for(Iterator it2 =  map2.keySet().iterator();it2.hasNext();){
            Object key = it2.next();
            System.out.println(key+"="+map2.get(key));

        }
    }
}

運行結果如下：

HashMap的遍歷方法

public static void main(String args[]){
        System.out.println("*************************LinkedHashMap*************");
        Map<Integer,String> map = new LinkedHashMap<Integer,String>();
        map.put(7, "阿里");
        map.put(9, "騰訊");
        map.put(6,"百度");

        //遍歷map
        //方法1.1，keySet遍歷,同時獲取key和value：6=百度
        for (Iterator it = map.keySet().iterator(); it.hasNext();)
        {
            Object key = it.next();
            System.out.println( key+"="+ map.get(key));
        }

        //方法1.2,keySet遍歷,只需要map的key或者value
//        //KeySet 獲取key
//        for (Integer key : map.keySet()) {
//            System.out.println(key);
//        }
//        // values 獲取value
//        for (String value : map.values()) {
//            System.out.println(value);
//        }

        //方法2,Iterator遍歷,可刪除元素：Key: 7;   Value: 阿里
//        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
//        while (it.hasNext()) {
//            Map.Entry<Integer, String> e2 = it.next();
//            // e2.remove(); 刪除元素
//            System.out.println("Key: " + e2.getKey() + ";   Value: " + e2.getValue());
//        }

        //方法3，entrySet遍歷, 同時獲取key，value，推薦使用
//        for (Map.Entry<Integer, String> entry : map.entrySet()) {
//            System.out.println(entry.getKey() + ":" + entry.getValue());
//        }

        //方法4，Lambda遍歷，性能低於entrySet
//         map.forEach((key, value) -> {
//              System.out.println(key + ":" + value);
//         });
｝

Set類型對比

HashSet：遍歷時，獲取數據的順序完全隨機；不支持線程同步；
LinkedHashSet：可以保存記錄的插入順序，遍歷輸出的順序和插入的順序一致；
TreeSet：遍歷時，保存的記錄可以根據鍵自動排序；

HastSet和TreeSet是Set的兩種典型：一般我們首選HashSet，當我們需要保持一個排序的set時，才選擇TreeSet。由於TreeSet需要紅黑樹來維護元素次序，所有HashSet比TreeSet的性能更好。
而LinkedHashSet是HashSet的一個子類，LinkedHashSet的底層實現是鏈表，所以可以維護元素的插入順序，因此遍歷LinkedHashSet會更快；但對於普通的插入、刪除等操作，HashSet效率更高。

從三種Set集合和Map集合對比來看，Set和Map驚人的相似。其實從Java源碼看，Java是先實現了Map，然後通過包裝一個所有value都爲Null的Map就實現了Set集合。所以Map子類和Set子類名字相似、Map裏key集和Set集合裏元素的存儲形式也相似、且Set和Map子類功能也相似。

/**
     * Set集合
     * @param args
     */
    public static void main(String args[]){
        //LinkedHashSet：可以保存記錄的插入順序，遍歷輸出的順序和插入的順序一致；
        System.out.println("*************************LinkedHashSet*************");
        LinkedHashSet set0 = new LinkedHashSet();
        set0.add(7);
        set0.add(9);
        set0.add(6);
        set0.add(8);
        set0.add(null);
        System.out.println(set0);

        //HashSet：遍歷時，獲取數據的順序完全隨機；不支持線程同步；
        System.out.println("*************************HashSet*************");
        HashSet set1 = new HashSet();
        set1.add(7);
        set1.add(9);
        set1.add(6);
        set1.add(8);
        set1.add(null);
        System.out.println(set1);

        //TreeSet：遍歷時，保存的記錄可以根據鍵自動排序；
        System.out.println("*************************TreeSet*************");
        //1、自然排序,元素對象默認實現Comparator接口
        TreeSet set2 = new TreeSet();
        set2.add(7);
        set2.add(9);
        set2.add(6);
        set2.add(8);
        System.out.println(set2);
        //2、定製排序，元素對象不需要實現接口，創建set集合時提供Comparator接口與集合關聯
        
    }
}

運行結果如下：

List集合對比

ArrayList：是基於數組的線性表，隨機訪問時性能好，使用隨機訪問法(get)遍歷較好
LinkedList：是基於鏈表的線性表，執行刪除、插入時性能比較好，使用迭代器Iterator遍歷較好
PriorityQueue：隊列實現類，元素順序是按隊列元素大小進行排序，所以並不是標準隊列，不符合先進先出
ArrayDeque：雙端隊列，允許從兩端來操作；還可以當棧使用(pop()/push())

  /**
     * List集合
     * @param args
     */
    public static void main(String args[]){
        //ArrayList：是基於數組的線性表，隨機訪問時性能好，使用隨機訪問法(get)遍歷較好
        System.out.println("*************************LinkedHashSet*************");
        List list0 = new ArrayList();
        list0.add(7);
        list0.add(9);
        list0.add(6);
        list0.add(8);
        list0.add(null);
        //for(int i = 0;i <list0.size(); i++){
        //    System.out.println(list0.get(i));
       // }
        System.out.println(list0);

        //LinkedList：是基於鏈表的線性表，執行刪除、插入時性能比較好，使用迭代器Iterator遍歷較好
        //是Lint接口實現類，可以當list；還實現了deque接口，可以當雙端隊列，也可以當棧
        System.out.println("*************************LinkedList*************");
        LinkedList list1 = new LinkedList();
        //------------------------預想排在第三位
        list1.add(7);
        list1.offer(9);
        //棧頂部------------------預想排在第二位
        list1.push(6);
        //隊列頭部(相當於棧頂部)--預想排在第一位
        list1.offerFirst(8);
        //隊列尾部
        list1.offerLast(null);
        //for (Iterator<Integer> iterator = list1.iterator(); iterator.hasNext();) {
        //      System.out.println(iterator.next());
        //}
        System.out.println(list1);

        //PriorityQueue：隊列實現類，元素順序是按隊列元素大小進行排序，所以並不是標準隊列，不符合先進先出
        System.out.println("*************************PriorityQueue*************");
        //1、自然排序,元素對象默認實現Comparator接口
        PriorityQueue queue = new PriorityQueue();
        queue.offer(7);
        queue.offer(9);
        queue.offer(6);
        queue.offer(8);
        System.out.println(queue);
        //2、定製排序，元素對象不需要實現接口，創建set集合時提供Comparator接口與集合關聯

        //ArrayDeque：雙端隊列，允許從兩端來操作；還可以當棧使用(pop()/push())
        //程序需要使用棧時，推薦使用ArrayDeque，儘量避免使用stack
        System.out.println("*************************ArrayDeque*************");
        //1、自然排序,元素對象默認實現Comparator接口
        ArrayDeque deque = new ArrayDeque();
        deque.offer(7);
        deque.offer(9);
        deque.offer(6);
        deque.offer(8);
        //訪問第一個，但並不將第一個元素刪除出棧
        System.out.println(queue.peek());
        //訪問第一個，但將第一個元素刪除出棧????????爲什麼沒有pop()方法
        //System.out.println(queue.pop());
        System.out.println(queue);
    }
}