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

最新推荐文章于 2024-04-10 18:25:19 发布
最新推荐文章于 2024-04-10 18:25:19 发布
阅读量939 收藏 3
点赞数
分类专栏： java 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45817985/article/details/134397181
版权

概要：

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

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

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

1、Map用法

类型介绍

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

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

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

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

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

  1. 一个用于帮助我们实现自己的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();

2、四种常用Map插入与读取性能比较在这里插入图片描述

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

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

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

总结

增强for循环使用方便，但性能较差，不适合处理超大量级的数据。

迭代器的遍历速度要比增强for循环快很多，是增强for循环的2倍左右。

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

4、Map 排序

HashMap、Hashtable、LinkedHashMap排序
注：
TreeMap也可以使用此方法进行排序，但是更推荐下面的方法。

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

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

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
在这里插入图片描述

princeAladdin
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java中关于Map的三种遍历方法详解
09-05
本篇文章是对java中关于Map的三种遍历方法进行了详细的分析介绍，需要的朋友参考下
【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基础篇
最新发布
qq_45649553的博客
04-10 951
Java Map基础篇
Java中的Map及其使用
热门推荐
taraex的博客
05-15 17万+
Map Map集合概述和特点 概述： 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值 Map接口和Collection接口的不同 Map是双列的,Collection是单列的 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效 Map集合的功能概述 a:添加功能 V put...
java的Map集合 详解Map集合
weixin_46140377的博客
04-10 7万+
java 集合 Map， HashMap，LinkedHashMap，Hashtable， 详解Map集合
java基础——Map
Flipped7777的博客
04-23 6253
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。注意，学生姓名相同并且年龄相同视为同一名学生。//构造方法 //get/set @Override public boolean equals(Object o) {} }//1,创建Hashmap集合对象。//2,添加元素。map . put(new Student("lisi" , 28) , "上海");
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遍历方式(非常好用)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
mapstruct-1.3.1.Final-API文档-中文版.zip
05-09
包含翻译后的API文档：mapstruct-1.3.1.Final-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.mapstruct:mapstruct:1.3.1.Final； 标签：mapstruct、jar包、java、中文文档； 使用方法：解压翻译后的API文档，...
Java中map遍历方式的选择问题详解
08-29
主要介绍了Java中map遍历方式的选择问题的相关内容，小编觉得挺不错的，在则里分享给大家，需要的朋友可以参考下。
java集合map取key使用示例 java遍历map
09-04
主要介绍了java集合map取key使用示例,需要的朋友可以参考下
jQuery 遍历map()方法详解
01-19
一、定义和用法 map() 把每个元素通过函数传递到当前匹配集合中，生成包含返回值的新的 jQuery 对象。 二、语法 .map(callback(index,domElement)) 三、详细说明 由于返回值是 jQuery 封装的数组，使用 get() 来...
mapstruct-jdk8-1.2.0.Final-API文档-中文版.zip
06-26
包含翻译后的API文档：mapstruct-jdk8-1.2.0.Final-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.mapstruct:mapstruct-jdk8:1.2.0.Final； 标签：mapstruct、jdk8、中文文档、jar包、java； 使用方法：解压...
Java基础知识之Map
qq_45344586的博客
03-22 8013
Java基础知识之Map的使用
Java集合详解--Map
Striving
06-30 2967
1.Map概述 前面我们学习的Collection叫做集合，它可以快速查找现有的元素。 而Map在《Core Java》中称之为–>映射 HashMap：键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放；允许null的键或值； Hashtable：线程安全的，不允许null的键或值； Properties:：key和value都是String类型，用来读配置文件； TreeMap：对key排好序的Map; key 就是TreeSet, value对应
【Java】Map介绍和使用
威威的博客
07-22 1万+
Map集合详细讲解
⼿写⼀下HashMap的⼏种遍历⽅式 - Entry 遍历 - keySet 遍历 - foreach遍历 - keySet foreach遍历
07-27
HashMap的几种遍历方式如下： 1. Entry遍历：使用entrySet()方法可以同时遍历Map里面的Key和Value。可以通过迭代器或者foreach循环来实现。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用entrySet()方法遍历 for (Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); // 处理key和value } ``` 2. keySet遍历：使用keySet()方法可以遍历Map里面的Key。可以通过迭代器或者foreach循环来实现。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用keySet()方法遍历 for (String key : map.keySet()) { Integer value = map.get(key); // 处理key和value } ``` 3. foreach遍历：在JDK8及以上版本中，可以直接使用foreach循环来遍历HashMap的键值对。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用foreach遍历 map.forEach((key, value) -> { // 处理key和value }); ``` 4. keySet foreach遍历：在JDK8及以上版本中，可以使用keySet()方法获取键的集合，然后使用foreach循环遍历。例如： ```java HashMap<String, Integer> map = new HashMap<>(); // 添加键值对 map.put("A", 1); map.put("B", 2); map.put("C", 3); // 使用keySet foreach遍历 for (String key : map.keySet()) { Integer value = map.get(key); // 处理key和value } ``` 以上是HashMap的几种常见遍历方式。根据具体的需求，可以选择适合的遍历方式来操作HashMap的键值对。 #### 引用[.reference_title] - *1* *3* [Java - 关于HashMap通过keySet遍历kv的二次调用问题](https://blog.csdn.net/Zong_0915/article/details/120905738)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [HashMap的七种遍历方式](https://blog.csdn.net/maojian_ohhey/article/details/115431835)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

princeAladdin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值