Java map 详解 - 用法、遍历、排序、常用API等

尊重原创：http://www.cnblogs.com/lzq198754/p/5780165.html

概要：

java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。

Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。

本文主要介绍java map的初始化、用法、map的四种常用的遍历方式、map的排序以及常用api。

| |目录

1Map用法

类型介绍

Java 自带了各种 Map 类。这些 Map 类可归为三种类型：

1. 通用Map，用于在应用程序中管理映射，通常在 java.util 程序包中实现

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

2. 专用Map，通常我们不必亲自创建此类Map，而是通过某些其他类对其进行访问

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

3. 一个用于帮助我们实现自己的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 初始化

Java | 复制


1

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

插入元素

Java | 复制


1

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

获取元素

Java | 复制


1

map.get("key1")

移除元素

Java | 复制


1

map.remove("key1");

清空map

Java | 复制


1

map.clear();

2四种常用Map插入与读取性能比较

测试环境

jdk1.7.0_80

测试结果

  插入10次平均(ms) 读取10次平均(ms)
  1W 10W 100W 1W 10W 100W
HashMap 56 261 3030 2 21 220
LinkedHashMap 25 229 3069 2 20 216
TreeMap 29 295 4117 5 103 1446
Hashtable 24 234 3275 2 22 259

测试代码

Java | 复制


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

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");

    }

}

3Map 遍历

初始化数据

Java | 复制


1

2

3

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

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

map.put("key2", "value2");

增强for循环遍历

使用keySet()遍历

Java | 复制


1

2

3

for (String key : map.keySet()) {

    System.out.println(key + " ：" + map.get(key));

}

使用entrySet()遍历

Java | 复制


1

2

3

for (Map.Entry<String, String> entry : map.entrySet()) {

    System.out.println(entry.getKey() + " ：" + entry.getValue());

}

迭代器遍历

使用keySet()遍历

Java | 复制


1

2

3

4

5

Iterator<String> iterator = map.keySet().iterator();

while (iterator.hasNext()) {

    String key = iterator.next();

    System.out.println(key + "　：" + map.get(key));

}

使用entrySet()遍历

Java | 复制


1

2

3

4

5

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次迭代，比较用时。

代码

Java | 复制


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

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");

    }

}

运行三次，比较结果

第一次

Text | 复制


1

2

3

4

增强for循环，keySet迭代 -> 37 ms

增强for循环，entrySet迭代 -> 19 ms

迭代器，keySet迭代 -> 14 ms

迭代器，entrySet迭代 -> 9 ms

第二次

Text | 复制


1

2

3

4

增强for循环，keySet迭代 -> 29 ms

增强for循环，entrySet迭代 -> 22 ms

迭代器，keySet迭代 -> 19 ms

迭代器，entrySet迭代 -> 12 ms

第三次

Text | 复制


1

2

3

4

增强for循环，keySet迭代 -> 27 ms

增强for循环，entrySet迭代 -> 19 ms

迭代器，keySet迭代 -> 18 ms

迭代器，entrySet迭代 -> 10 ms

平均值

Text | 复制


1

2

3

4

增强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倍左右。

4Map 排序

HashMap、Hashtable、LinkedHashMap排序

注：

TreeMap也可以使用此方法进行排序，但是更推荐下面的方法。

Java | 复制


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

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

map.put("a", "c");

map.put("b", "b");

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>>() {

    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进行升序排序，如果想改变默认的顺序，可以使用比较器:

Java | 复制


1

2

3

4

5

6

7

8

9

10

11

12

Map<String, String> map = new TreeMap<String, String>(new Comparator<String>() {

    public int compare(String obj1, String obj2) {

        return obj2.compareTo(obj1);// 降序排序

    }

});

map.put("a", "c");

map.put("b", "b");

map.put("c", "a");

for (String key : map.keySet()) {

    System.out.println(key + " ：" + map.get(key));

}

按value排序(通用)

Java | 复制


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

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

        map.put("a", "c");

        map.put("b", "b");

        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>>() {

            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));

        }

5常用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 中的键-值映射的数目

原文地址：https://www.cnblogs.com/xiaohouzai/p/8340922.html

时间： 2024-10-10 14:44:17

Java map 详解 - 用法、遍历、排序、常用API等的相关文章

Java集合详解5：深入理解LinkedHashMap和LRU缓存

Java集合详解5:深入理解LinkedHashMap和LRU缓存 今天我们来深入探索一下LinkedHashMap的底层原理,并且使用linkedhashmap来实现LRU缓存. 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客: https://h2pl.github.io/2018/05/11/collection5 更多关于Java后端学习的内容请到我的CSDN博客上查看:https://blog.csdn.net

List、Set、Map详解及区别

一.List接口 List是一个继承于Collection的接口,即List是集合中的一种.List是有序的队列,List中的每一个元素都有一个索引:第一个元素的索引值是0,往后的元素的索引值依次+1.和Set不同,List中允许有重复的元素.实现List接口的集合主要有:ArrayList.LinkedList.Vector.Stack. ArrayList ArrayList是一个动态数组,也是我们最常用的集合.它允许任何符合规则的元素插入甚至包括null.每一个ArrayList都有一个初

Java反射详解

Java反射详解 分类:java, 基础日期:2012-07-20作者:ticmy 19 反射,是Java中非常重要的一个功能,如果没有反射,可以说很多框架都难以实现. 什么是反射?说白了就是可以通过Java代码获取装载到方法区的类信息的手段. 当装载一个类时,会在方法区产生一个数据结构,该结构中包含着装载的类的相关信息.字节码可以看成是数据流,那么方法区的这种数据结构可以说是字节码数据流的结构化表现.装载的最终产物就是java.lang.Class类的一个对象,它是Java程序与方法区内部数据

Java IO 详解

Java IO 详解 初学java,一直搞不懂java里面的io关系,在网上找了很多大多都是给个结构图草草描述也看的不是很懂.而且没有结合到java7 的最新技术,所以自己来整理一下,有错的话请指正,也希望大家提出宝贵意见. 首先看个图:(如果你也是初学者,我相信你看了真个人都不好了,想想java设计者真是煞费苦心啊!) 这是java io 比较基本的一些处理流,除此之外我们还会提到一些比较深入的基于io的处理类,比如console类,SteamTokenzier,Externalizable接

linux awk命令详解（都是常用命令）

原文:http://www.cnblogs.com/ggjucheng/archive/2013/01/13/2858470.html 简介 awk是一个强大的文本分析工具,相对于grep的查找,sed的编辑,awk在其对数据分析并生成报告时,显得尤为强大.简单来说awk就是把文件逐行的读入,以空格为默认分隔符将每行切片,切开的部分再进行各种分析处理. awk有3个不同版本: awk.nawk和gawk,未作特别说明,一般指gawk,gawk 是 AWK 的 GNU 版本. awk其名称得自于它

【转载】Java泛型详解

[转载]http://www.importnew.com/24029.html 对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下. 本文参考java 泛型详解.Java中的泛型方法. java泛型详解 1. 概述 泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用. 什么是泛型?为什么要使用泛型? 泛型,即"参数化类型".一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参.那么参数化

Java基础11：Java泛型详解

Java基础11:Java泛型详解 泛型概述 泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用. 什么是泛型?为什么要使用泛型? 泛型,即"参数化类型".一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参.那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参). 泛型的本质是为了参数化类型(在不创建新的类型的

Java集合详解6：TreeMap和红黑树

Java集合详解6:TreeMap和红黑树 初识TreeMap 之前的文章讲解了两种Map,分别是HashMap与LinkedHashMap,它们保证了以O(1)的时间复杂度进行增.删.改.查,从存储角度考虑,这两种数据结构是非常优秀的.另外,LinkedHashMap还额外地保证了Map的遍历顺序可以与put顺序一致,解决了HashMap本身无序的问题. 尽管如此,HashMap与LinkedHashMap还是有自己的局限性----它们不具备统计性能,或者说它们的统计性能时间复杂度并不是很好才

Java集合详解7：HashSet，TreeSet与LinkedHashSet

Java集合详解7:HashSet,TreeSet与LinkedHashSet 今天我们来探索一下HashSet,TreeSet与LinkedHashSet的基本原理与源码实现,由于这三个set都是基于之前文章的三个map进行实现的,所以推荐大家先看一下前面有关map的文章,结合使用味道更佳. 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人博客: https://h2pl.github.io/2018/05/12/colle