Java map 詳解 - 用法、遍歷、排序、常用API等

原文地址;  https://baike.xsoftlab.net/view/250.html#1

Map用法

類型介紹

Java 自帶了各種 Map 類，這些 Map 類可歸為三種類型：

通用Map

用於在應用程序中管理映射，通常在 java.util 程序包中實現

HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap

專用Map

通常我們不必親自創建此類Map，而是通過某些其他類對其進行訪問

java.util.jar.Attributes、javax.print.attribute.standard.PrinterStateReasons、java.security.Provider、java.awt.RenderingHints、javax.swing.UIDefaults

自行實現Map

一個用於幫助我們實現自己的Map類的抽象類

AbstractMap

類型區別

HashMap

最常用的Map,它根據鍵的HashCode 值存儲數據,根據鍵可以直接獲取它的值，具有很快的訪問速度。HashMap最多只允許一條記錄的鍵為Null(多條會覆蓋);允許多條記錄的值為 Null。非同步的。

TreeMap

能夠把它保存的記錄根據鍵(key)排序,默認是按升序排序，也可以指定排序的比較器，當用Iterator 遍歷TreeMap時，得到的記錄是排過序的。TreeMap不允許key的值為null。非同步的。

Hashtable

與 HashMap類似,不同的是:key和value的值均不允許為null;它支持線程的同步，即任一時刻只有一個線程能寫Hashtable,因此也導致了Hashtale在寫入時會比較慢。

LinkedHashMap

保存了記錄的插入順序，在用Iterator遍歷LinkedHashMap時，先得到的記錄肯定是先插入的.在遍歷的時候會比HashMap慢。key和value均允許為空，非同步的。

Map 初始化

 

 

Map<String, String> map = new HashMap<String, String>();

插入元素

 

 

map.put("key1", "value1");

獲取元素

 

 

map.get("key1")

移除元素

 

 

map.remove("key1");

清空map

 

 

map.clear();

四種常用Map插入與讀取性能比較

插入10次平均(ms)

	1W	10W	100W
HashMap	56	261	3030
LinkedHashMap	25	229	3069
TreeMap	29	295	4117
Hashtable	24	234	3275

讀取10次平均(ms)

	1W	10W	100W
HashMap	2	21	220
LinkedHashMap	2	20	216
TreeMap	5	103	1446
Hashtable	2	22	259

測試代碼

 

 

package net.xsoftlab.baike;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.UUID;

public class Test {
    static int hashMapW = 0;
    static int hashMapR = 0;
    static int linkMapW = 0;
    static int linkMapR = 0;
    static int treeMapW = 0;
    static int treeMapR = 0;
    static int hashTableW = 0;
    static int hashTableR = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Test test = new Test();
            test.test(100 * 10000);
            System.out.println();
        }
        System.out.println("hashMapW = " + hashMapW / 10);
        System.out.println("hashMapR = " + hashMapR / 10);
        System.out.println("linkMapW = " + linkMapW / 10);
        System.out.println("linkMapR = " + linkMapR / 10);
        System.out.println("treeMapW = " + treeMapW / 10);
        System.out.println("treeMapR = " + treeMapR / 10);
        System.out.println("hashTableW = " + hashTableW / 10);
        System.out.println("hashTableR = " + hashTableR / 10);
    }

    public void test(int size) {
        int index;
        Random random = new Random();
        String[] key = new String[size];
        // HashMap 插入
        Map<String, String> map = new HashMap<String, String>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            key[i] = UUID.randomUUID().toString();
            map.put(key[i], UUID.randomUUID().toString());
        }
        long end = System.currentTimeMillis();
        hashMapW += (end - start);
        System.out.println("HashMap插入耗時 = " + (end - start) + " ms");
        // HashMap 讀取
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            index = random.nextInt(size);
            map.get(key[index]);
        }
        end = System.currentTimeMillis();
        hashMapR += (end - start);
        System.out.println("HashMap讀取耗時 = " + (end - start) + " ms");
        // LinkedHashMap 插入
        map = new LinkedHashMap<String, String>();
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            key[i] = UUID.randomUUID().toString();
            map.put(key[i], UUID.randomUUID().toString());
        }
        end = System.currentTimeMillis();
        linkMapW += (end - start);
        System.out.println("LinkedHashMap插入耗時 = " + (end - start) + " ms");
        // LinkedHashMap 讀取
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            index = random.nextInt(size);
            map.get(key[index]);
        }
        end = System.currentTimeMillis();
        linkMapR += (end - start);
        System.out.println("LinkedHashMap讀取耗時 = " + (end - start) + " ms");
        // TreeMap 插入
        key = new String[size];
        map = new TreeMap<String, String>();
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            key[i] = UUID.randomUUID().toString();
            map.put(key[i], UUID.randomUUID().toString());
        }
        end = System.currentTimeMillis();
        treeMapW += (end - start);
        System.out.println("TreeMap插入耗時 = " + (end - start) + " ms");
        // TreeMap 讀取
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            index = random.nextInt(size);
            map.get(key[index]);
        }
        end = System.currentTimeMillis();
        treeMapR += (end - start);
        System.out.println("TreeMap讀取耗時 = " + (end - start) + " ms");
        // Hashtable 插入
        key = new String[size];
        map = new Hashtable<String, String>();
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            key[i] = UUID.randomUUID().toString();
            map.put(key[i], UUID.randomUUID().toString());
        }
        end = System.currentTimeMillis();
        hashTableW += (end - start);
        System.out.println("Hashtable插入耗時 = " + (end - start) + " ms");
        // Hashtable 讀取
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            index = random.nextInt(size);
            map.get(key[index]);
        }
        end = System.currentTimeMillis();
        hashTableR += (end - start);
        System.out.println("Hashtable讀取耗時 = " + (end - start) + " ms");
    }
}

 

Map 遍歷

初始化數據

 

 

Map<String, String> map = new HashMap<String, String>();
map.put("key1", "value1");
map.put("key2", "value2");

增強for循環遍歷

使用keySet()遍歷

 

 

for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

使用entrySet()遍歷

 

 

for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " ：" + entry.getValue());
}

迭代器遍歷

使用keySet()遍歷

 

 

Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    System.out.println(key + "　：" + map.get(key));
}

使用entrySet()遍歷

 

 

Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, String> entry = iterator.next();
    System.out.println(entry.getKey() + "　：" + entry.getValue());
}

HashMap四種遍歷方式性能比較

比較方式

分別對四種遍歷方式進行10W次迭代，比較用時。

代碼

 

 

package net.xsoftlab.baike;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class TestMap {
    public static void main(String[] args) {
        // 初始化，10W次賦值
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < 100000; i++)
            map.put(i, i);

        /** 增強for循環，keySet迭代 **/
        long start = System.currentTimeMillis();
        for (Integer key : map.keySet()) {
            map.get(key);
        }
        long end = System.currentTimeMillis();
        System.out.println("增強for循環，keySet迭代 -> " + (end - start) + " ms");

        /** 增強for循環，entrySet迭代 */
        start = System.currentTimeMillis();
        for (Entry<Integer, Integer> entry : map.entrySet()) {
            entry.getKey();
            entry.getValue();
        }
        end = System.currentTimeMillis();
        System.out.println("增強for循環，entrySet迭代 -> " + (end - start) + " ms");

        /** 迭代器，keySet迭代 **/
        start = System.currentTimeMillis();
        Iterator<Integer> iterator = map.keySet().iterator();
        Integer key;
        while (iterator.hasNext()) {
            key = iterator.next();
            map.get(key);
        }
        end = System.currentTimeMillis();
        System.out.println("迭代器，keySet迭代 -> " + (end - start) + " ms");

        /** 迭代器，entrySet迭代 **/
        start = System.currentTimeMillis();
        Iterator<Map.Entry<Integer, Integer>> iterator1 = map.entrySet().iterator();
        Map.Entry<Integer, Integer> entry;
        while (iterator1.hasNext()) {
            entry = iterator1.next();
            entry.getKey();
            entry.getValue();
        }
        end = System.currentTimeMillis();
        System.out.println("迭代器，entrySet迭代 -> " + (end - start) + " ms");
    }
}

 

運行三次，比較結果

第一次

 

 

增強for循環，keySet迭代 -> 37 ms
增強for循環，entrySet迭代 -> 19 ms
迭代器，keySet迭代 -> 14 ms
迭代器，entrySet迭代 -> 9 ms

第二次

 

 

增強for循環，keySet迭代 -> 29 ms
增強for循環，entrySet迭代 -> 22 ms
迭代器，keySet迭代 -> 19 ms
迭代器，entrySet迭代 -> 12 ms

第三次

 

 

增強for循環，keySet迭代 -> 27 ms
增強for循環，entrySet迭代 -> 19 ms
迭代器，keySet迭代 -> 18 ms
迭代器，entrySet迭代 -> 10 ms

平均值

 

 

增強for循環，keySet迭代 -> 31 ms
增強for循環，entrySet迭代 -> 20 ms
迭代器，keySet迭代 -> 17 ms
迭代器，entrySet迭代 -> 10.33 ms

總結

1. 增強for循環使用方便，但性能較差，不適合處理超大量級的數據。

2. 迭代器的遍歷速度要比增強for循環快很多，是增強for循環的2倍左右。

3. 使用entrySet遍歷的速度要比keySet快很多，是keySet的1.5倍左右。

Map 排序

HashMap、Hashtable、LinkedHashMap排序

注：TreeMap也可以使用此方法進行排序，但是更推薦下面的方法。

 

 

Map<String, String> map = new HashMap<String, String>();
map.put("b", "b");
map.put("a", "c");
map.put("c", "a");

// 通過ArrayList構造函數把map.entrySet()轉換成list
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
// 通過比較器實現比較排序
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    @Override
    public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
        return mapping1.getKey().compareTo(mapping2.getKey());
    }
});

for (Map.Entry<String, String> mapping : list) {
    System.out.println(mapping.getKey() + " ：" + mapping.getValue());
}

 

TreeMap排序

TreeMap默認按key進行升序排序，如果想改變默認的順序，可以使用比較器:

 

 

Map<String, String> map = new TreeMap<String, String>(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        // 降序排序
        return o1.compareTo(o2);
    }
});

map.put("b", "b");
map.put("a", "c");
map.put("c", "a");
for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

按value排序(通用)

 

 

Map<String, String> map = new TreeMap<String, String>();
map.put("b", "b");
map.put("a", "c");
map.put("c", "a");

// 通過ArrayList構造函數把map.entrySet()轉換成list
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
// 通過比較器實現比較排序
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    @Override
    public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
        return mapping1.getValue().compareTo(mapping2.getValue());
    }
});

for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

 

常用API

方法	描述
clear()	從 Map 中刪除所有映射
remove(Object key)	從 Map 中刪除鍵和關聯的值
put(Object key, Object value)	將指定值與指定鍵相關聯
putAll(Map t)	將指定 Map 中的所有映射復制到此 map
entrySet()	返回 Map 中所包含映射的 Set 視圖。Set 中的每個元素都是一個 Map.Entry 對象，可以使用 getKey() 和 getValue() 方法（還有一個 setValue() 方法）訪問后者的鍵元素和值元素
keySet()	返回 Map 中所包含鍵的 Set 視圖。刪除 Set 中的元素還將刪除 Map 中相應的映射（鍵和值）
values()	返回 map 中所包含值的 Collection 視圖。刪除 Collection 中的元素還將刪除 Map 中相應的映射（鍵和值）
get(Object key)	返回與指定鍵關聯的值
containsKey(Object key)	如果 Map 包含指定鍵的映射，則返回 true
containsValue(Object value)	如果此 Map 將一個或多個鍵映射到指定值，則返回 true
isEmpty()	如果 Map 不包含鍵-值映射，則返回 true
size()	返回 Map 中的鍵-值映射的數目