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

最新推荐文章于 2023-07-22 11:18:40 发布
最新推荐文章于 2023-07-22 11:18:40 发布
阅读量370 收藏 2
点赞数 1
分类专栏： java

概要：

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 中的键-值映射的数目
zy_0602
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java深入学习
02-20
Java深入学习
java基础——Map
Flipped7777的博客
04-23 6033
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。注意，学生姓名相同并且年龄相同视为同一名学生。//构造方法 //get/set @Override public boolean equals(Object o) {} }//1,创建Hashmap集合对象。//2,添加元素。map . put(new Student("lisi" , 28) , "上海");
【Java】Map集合概述
weixin_60719453的博客
11-20 4万+
目录 一、前言 二、Map介绍 三、Map的基本功能 Map功能演示： 四、Map集合的获取功能 Map遍历演示： 一、前言 map集合是我们常使用的集合，了解和使用map集合是必要的 二、Map介绍 基本形式： public interface Map<K,V> Map是一个接口，我们不能直接创建对象，可以通过多态的形式创建对象，Map中有两个 参数，一个是K表示键，一个是V表示值，且一个键有且对应一个值，Map中不能包含重复的 键，若是有重复的键...
【Java 基础篇】Java Map 详解
繁依Fanyi的博客
06-25 1万+
Map接口是一个键值对的集合，它继承自Collection接口中的size()和isEmpty()等方法，同时还提供了根据键查找值的方法，以及添加、删除和更新键值对的方法。在Java中，Map接口有几个常见的实现类，每个实现类都具有不同的性能和用途。HashMap：基于哈希表实现，具有快速的查找和插入操作，适用于需要快速查找键值对的场景。TreeMap：基于红黑树实现，可以对键进行排序，并提供了一系列与排序相关的方法，适用于需要对键进行排序的场景。
java的Map集合 详解Map集合
weixin_46140377的博客
04-10 7万+
java 集合 Map， HashMap，LinkedHashMap，Hashtable， 详解Map集合
java遍历Map的几种方法分析
09-01
主要介绍了java遍历Map的几种方法,结合实例形式分析了使用循环与迭代等方法操作Map遍历的相关技巧,需要的朋友可以参考下
mapstruct-1.1.0.Final-API文档-中文版.zip
07-12
包含翻译后的API文档：mapstruct-1.1.0.Final-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.mapstruct:mapstruct:1.1.0.Final； 标签：mapstruct、中文文档、jar包、java； 使用方法：解压翻译后的API文档，...
Java 遍历取出Map集合key-value数据的4种方法
08-25
主要介绍了Java 遍历取出Map集合key-value数据的4种方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
JAVA8独有的map遍历方式(非常好用)
08-25
主要介绍了JAVA8独有的map遍历方式(非常好用)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java中关于Map的三种遍历方法详解
09-05
本篇文章是对java中关于Map的三种遍历方法进行了详细的分析介绍，需要的朋友参考下
【Java】Map介绍和使用
威威的博客
07-22 1万+
Map集合详细讲解
Java基础知识之Map
qq_45344586的博客
03-22 7273
Java基础知识之Map的使用
【Java-API】map遍历的4种方式
m0_64210833的博客
07-21 6万+
map遍历的4种方式
Java基础-Map
m0_56060952的博客
03-14 233
1.Map的常见API 方法名称 说明 V put(K key , V value) 添加元素(如果键存在，覆盖value,并返回原有的value) V remove (Object key) 根据键删除键值对元素 void clear() 移除所有的键值对元素 int size () 集合的长度 boolean isEmpty() 判断集合是否为空 boolean containKey(Object key) 判断集合是否包含指定
Java中的Map及其使用
热门推荐
taraex的博客
05-15 17万+
Map Map集合概述和特点 概述： 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值 Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效 Map集合的功能概述 a:添加功能 V put...
Java map详解 - 用法、遍历、排序、常用API等
ITDragon博客
12-10 8872
Java map详解 - 用法、遍历、排序、常用API等 博客来自：http://baike.xsoftlab.net/view/250.html javamap遍历用法排序 概要： java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”
JAVA的Map详解
tastyrekeke的博客
11-13 821
JAVA的Map详解 Map集合 一、 Map集合 1.1 概述 Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。 Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。 Collection中的集合...
Java集合之Map
Jacksjie的博客
07-22 677
在Java中，Map 是一种用于存储键值对的数据结构。它提供了一种通过键来快速查找和访问值的方式。Map 接口有多个实现类，在常用的实现类中包括 HashMap、TreeMap 和 LinkedHashMap。 Map 的作用主要有以下几点： 映射关系：Map 提供了一种将键映射到值的关联关系。通过指定一个唯一的键，可以快速检索和获取对应的值。 存储数据：Map 可以用于存储和组织大量的数据。每个键值对代表一个数据项，通过键的唯一性，可以方便地进行数据的添加、删除、修改和查找。
Java中Map详解
Zhujiang
03-05 2万+
用法 Map:java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的两种常用的遍历方式。 map存放值的时候通过put存放，如果key值相等的话会把之前存放的值覆盖。 ...
⼿写⼀下HashMap的⼏种遍历⽅式 - Entry 遍历 - keySet 遍历 - foreach遍历 - keySet foreach遍历
最新发布
07-27
1. Entry遍历：使用entrySet()方法可以同时遍历Map里面的Key和Value。可以通过迭代器或者foreach循环来实现。例如： ```java HashMap, Integer> map = new HashMap(); // 添加键值对 map.put("A", 1); map.put("B", ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值