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

最新推荐文章于 2024-08-02 18:42:00 发布
最新推荐文章于 2024-08-02 18:42:00 发布
阅读量683 收藏
点赞数
分类专栏： 个人总结学习 文章标签： map 遍历 迭代器 排序

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 初始化

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

插入元素

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

获取元素

1
map.get( "key1" )

移除元素

1
map.remove( "key1" );

清空map

1
map.clear();









测试代码：
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 遍历

初始化数据

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

增强for循环遍历

使用keySet()遍历

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

使用entrySet()遍历

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

迭代器遍历

使用keySet()遍历

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()遍历

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

代码

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

运行三次，比较结果

第一次

1
2
3
4
增强for循环，keySet迭代 -> 37 ms
增强for循环，entrySet迭代 -> 19 ms
迭代器，keySet迭代 -> 14 ms
迭代器，entrySet迭代 -> 9 ms

第二次

1
2
3
4
增强for循环，keySet迭代 -> 29 ms
增强for循环，entrySet迭代 -> 22 ms
迭代器，keySet迭代 -> 19 ms
迭代器，entrySet迭代 -> 12 ms

第三次

1
2
3
4
增强for循环，keySet迭代 -> 27 ms
增强for循环，entrySet迭代 -> 19 ms
迭代器，keySet迭代 -> 18 ms
迭代器，entrySet迭代 -> 10 ms

平均值

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也可以使用此方法进行排序，但是更推荐下面的方法。

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

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排序(通用)

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






其他map按key和value排序

http://blog.csdn.net/warhin/article/details/7101180


精准狙M_200
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
map 用法总结
cxz932652580的博客
04-18 2217
map用法总结1 map简介三级目录1 map简介2 map功能3 使用map3.1 向map添加元素 1 map简介 三级目录 1 map简介 map 是STL的一个关联容器，提供一对一的hash 1.1 第一个可以称为关键字（key），每个关键字只能在map中出现一次； 1.2 第二个可以称为该关键字的值（value）； 2 map功能 2.1 自动建立key - value 的对应，key 和value 可以是任意需要的类型，包括自定义类型。 2.2 map是有序的，会按照关键字从
Java核心技术：Java map 详解 - 用法、遍历、排序、常用API等
码农架构
09-07 273
Map用法 类型介绍 Java 自带了各种 Map 类，这些 Map 类可归为三种类型： 通用Map 用于在应用程序中管理映射，通常在 java.util 程序包中实现HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap 专用Map 通常我们不必亲自创建此类Map，而是通过某些其他类对其进行访问java.util.jar.Attributes、jav..
map常见用法
小道名宇
07-14 336
单独定义map map<typename1,typename2>mp,确定映射前类型键key和映射后类型值value //若为从字符型到整型的映射必须使用string而不能使用char #include<stdio.h> #include<map> using namespace std; int main() { map<char,int>m...
《Java基础-集合：深入了解Java中Map类的使用及实用技巧（最全篇）》
最新发布
大大大钢琴
08-02 973
Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将 List 看作是具有数值键的 Map。1. Map提供接口分别用于返回 键集、值集或键-值映射关系集。entrySet()用于返回键-值集的Set集合;keySet()用于返回键集的Set集合;values()用户返回值集的Collection集合,因为Map中不能包含重复的键；每个键最多只能映射到一个值。所以，键-值集、键集都是Set，值集时Collection。
Map的常见用法
weixin_33967071的博客
04-14 64
//java HashMap 循环遍历map的方法import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;//循环遍历map的方法public class CircleMa...
详解Java中Map用法
热门推荐
guomutian911的专栏
05-16 7万+
Map以按键/数值对的形式存储数据，这里要特别说明（ Map.Entry，是Map的内部类，它用来描述Map中的键/值对）。 Map是一个接口，我们平时多用它的实现类HashMap。 用例如下： public static void main(String args[]) { HashMap hashmap
java Map用法
hangzhang
01-19 1082
最近在做项目时用到了Map，发现对Map的用法并不是很上手，所以今天就抽时间总结一下Map。 查看API得知，Map是一个接口，是将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 1、遍历Map 遍历Map常用的有两种方法，第1种代码如下： Map map = new HashMap<>(); map.put("username", "zhang"); ma
Java类TreeMap常用API详解
WanAkiko.
08-02 1028
TreeMap - 测试类 package TreeMap_UtilityClass; import sun.reflect.generics.tree.Tree; import java.util.*; /** * TreeMap测试类 */ public class TreeMapTest { public static void main(String[] args) { // 向映射中添加元素(键不可以重复，值可以重复) TreeMap<I
个人笔记--Java_API
11-25
### Java核心API知识点详解 #### 一、集合框架 **1.1 什么是集合** 集合是Java编程语言中用于存储和操作多个元素的一种容器。它提供了动态管理元素的能力，允许在运行时添加或删除元素。 **1.2 集合与数组** - ...
java 1.8 map lambda_Java进阶篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用详解(很详细)...
weixin_33582311的博客
02-24 681
前言本篇主要讲述是Java中JDK1.8的一些新语法特性使用，主要是Lambda、Stream和LocalDate日期的一些使用讲解。LambdaLambda介绍Lambda 表达式(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda...
Java软件开发实战 Java基础与案例开发详解 4-5 增强for循环 共5页.pdf
07-07
- **运算符与表达式**：覆盖了各种运算符（算术、比较、逻辑等）及其使用方法。 - **控制结构**：包括顺序结构、选择结构（if-else语句、switch-case语句）和循环结构（while循环、do-while循环、for循环）。 - **...
Java 中Map 的用法详解
09-02
本文主要介绍java 中的Map 接口, 这里对Map 接口下的几个类做了详细介绍,希望对学习java 编程的小伙伴有所帮助
Java map 用法
timmyroy的博客
10-26 736
Java map 常用方法   Map的一般用法 1.声明一个Map : Map map = new HashMap(); 2 .向map中放值 ，注意： map是key-value的形式存放的，如： map.put("sa","dd"); 3 .从map中取值 : String str = map.get("sa").toString, 结果是： str = "dd' 4...
java map 的用法
高小波_heat 的博客
01-01 269
import java.util.*; public class MapKeyWord { public static void main(String[] args) { Map m1 = new HashMap(); Map m2 = new TreeMap(); m1.put("one",new Integer(1)); m2.put("two",new Integer(
java Map使用方法
pengli_123的博客
06-07 413
 Map&lt;Long,Integer&gt; objecC= new HashMap&lt;Long,Integer&gt;();        int size = dataList.size();        for(int i = 0;i&lt;size;i++){            Long UTCTime = dataList.get(i).getTime();        ...
java map 的用法_Java Map的用法
weixin_42546508的博客
02-20 151
/最常规的一种遍历方法，最常规就是最常用的，虽然不复杂，但很重要，这是我们最熟悉的，就不多说了！！ public static void work(Map map) { Collection c = map.values(); Iterator it = c.iterator(); for (; it.hasNext();) { ...
java中Map的用法
ambiyou的博客
05-28 1万+
Map是java中的接口，Map.Entry是Map的一个内部接口。 Map提供了一些常用方法，如keySet()、entrySet()等方法。 keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。 Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。 Map<Stri
map用法
little_nono
12-06 274
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * 遍历： key value * @author 小明 * */ public class HelloWorld { public static v...
map的用法
绵绵mm的博客
09-06 519
头文件： #include <map> map的特性是，所有元素都会根据元素的减值自动被排序。map的所有元素都是pair，同时拥有实值(value)和键值(key)。pair的第一个元素会被视为键值，第二个元素会被视为实值。map不允许两个元素拥有相同的键值。 一、定义 (1) map<string, int> Map; (2) 或者是：typedef m...
Java常用API与数据结构详解
本文档主要介绍了Java编程中的基础知识，特别是关于String类、常用API、数组与集合的使用。文章首先从String类开始，讲解了它的常用方法、字符串比较、StringBuffer与StringBuilder的区别，以及它们与String类的关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值