Java HashMap的遍历方式有哪些？

最新推荐文章于 2024-10-14 21:17:51 发布
最新推荐文章于 2024-10-14 21:17:51 发布
阅读量411 收藏 3
点赞数 3
分类专栏： Java面试题 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139105648
版权

在 Java 编程中，HashMap 是一个非常常用的数据结构。它不仅具有高效的查找和插入性能，还有多种遍历方式可供选择。今天我们来详细剖析 HashMap 的几种常见遍历方式，并结合源码与性能测试数据进行深度分析。

HashMap 常见的遍历方式

HashMap 提供了多种遍历方式，常见的包括：

  1. 使用 entrySet
  2. 使用 keySet
  3. 使用 forEach 方法
  4. 使用 Iterator
  5. 使用 Stream
  6. 使用 parallelStream

1. 使用 entrySet

使用 entrySet 迭代是最常见和高效的方式之一。entrySet 返回的是 Map.Entry 对象的集合，每个 Entry 对象包含一个键和值。示例代码如下：

java

Map<String, Integer> map = new HashMap<>();
map.put("one", 1);
map.put("two", 2);
map.put("three", 3);

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

entrySet 方式的源码解析：

java

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}

final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { HashMap.this.clear(); }
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new EntryIterator();
    }
    public final boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?,?> e = (Map.Entry<?,?>) o;
        Object key = e.getKey();
        Node<K,V> candidate = getNode(hash(key), key);
        return candidate != null && candidate.equals(e);
    }
    public final boolean remove(Object o) {
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Object value = e.getValue();
            return removeNode(hash(key), key, value, true, true) != null;
        }
        return false;
    }
    public final Spliterator<Map.Entry<K,V>> spliterator() {
        return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
    }
    public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }
}

从源码可以看出，entrySet 返回了一个内部类 EntrySet，该类继承自 AbstractSet 并实现了 Map.Entry 的集合视图。

2. 使用 keySet

keySet 返回的是 HashMap 中所有键的集合。示例代码如下：

java

for (String key : map.keySet()) {
    System.out.println("Key = " + key + ", Value = " + map.get(key));
}

keySet 方式的源码解析：

java

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new KeySet();
        keySet = ks;
    }
    return ks;
}

final class KeySet extends AbstractSet<K> {
    public final int size()                 { return size; }
    public final void clear()               { HashMap.this.clear(); }
    public final Iterator<K> iterator()     { return new KeyIterator(); }
    public final boolean contains(Object o) { return containsKey(o); }
    public final boolean remove(Object key) { return HashMap.this.removeNode(hash(key), key, null, false, true) != null; }
    public final Spliterator<K> spliterator() { return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0); }
    public final void forEach(Consumer<? super K> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e.key);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }
}

keySet 返回了一个内部类 KeySet，该类继承自 AbstractSet 并包含了所有键的集合视图。

3. 使用 forEach 方法

forEach 方法是 Java 8 引入的一个新特性，提供了更加简洁的遍历方式。示例代码如下：

java

map.forEach((key, value) -> System.out.println("Key = " + key + ", Value = " + value));

forEach 方式的源码解析：

java

public void forEach(BiConsumer<? super K, ? super V> action) {
    Node<K,V>[] tab;
    if (action == null)
        throw new NullPointerException();
    if (size > 0 && (tab = table) != null) {
        int mc = modCount;
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next)
                action.accept(e.key, e.value);
        }
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
}

forEach 方法直接遍历内部的 Node 数组，并对每个键值对执行指定的操作。

4. 使用 Iterator

使用 Iterator 可以更加灵活地控制遍历过程。示例代码如下：

java

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

5. 使用 Stream

Stream API 是 Java 8 引入的一个强大工具，用于处理集合数据。示例代码如下：

java

map.entrySet().stream().forEach(entry ->
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()));

6. 使用 parallelStream

parallelStream 提供了并行处理的能力，适用于需要并行计算的场景。示例代码如下：

java

map.entrySet().parallelStream().forEach(entry ->
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()));

性能分析

接下来，我们通过性能测试数据来对比这些遍历方式的效率。以下是测试结果：

无阻塞情况下的性能测试

java

Benchmark               Mode  Cnt     Score      Error  Units
Test.entrySet           avgt    5   288.651 ±   10.536  ns/op
Test.keySet             avgt    5   584.594 ±   21.431  ns/op
Test.lambda             avgt    5   221.791 ±   10.198  ns/op
Test.parallelStream     avgt    5  6919.163 ± 1116.139  ns/op

从测试结果可以看出，在没有阻塞的情况下，parallelStream 性能最低，而 lambda 表达式的性能最高。

存在阻塞情况下的性能测试

在遍历过程中加入阻塞代码 Thread.sleep(10) 后，性能测试结果如下：

java

Benchmark               Mode  Cnt           Score          Error  Units
Test.entrySet           avgt    5  1554828440.000 ± 23657748.653  ns/op
Test.keySet             avgt    5  1550612500.000 ±  6474562.858  ns/op
Test.lambda             avgt    5  1551065180.000 ± 19164407.426  ns/op
Test.parallelStream     avgt    5   186345456.667 ±  3210435.590  ns/op

当遍历过程中存在阻塞时，parallelStream 的性能显著提高，成为最高效的遍历方式。

总结

通过上述分析和性能测试数据，我们得出以下结论：

  1. 无阻塞情况：lambda 表达式遍历方式最为高效，而 parallelStream 性能最低。
  2. 存在阻塞情况：parallelStream 的并行处理优势显现，成为最高效的遍历方式。

在实际应用中，选择合适的遍历方式需要根据具体的使用场景和性能需求来决定。如果需要处理大量数据且存在阻塞操作，可以考虑使用 parallelStream 来提升性能。

qq_33326733
关注
专栏目录
Java性能优化-HashMap遍历的7种方式及性能测试对比
BADAO_LIUMANG_QIZHI的博客
07-11 1180
参考以上性能测试工具的使用。下面针对Java中对HashMap的7种遍历方式做性能测试。
Java中HashMap遍历的七种方法
第十七签
10-18 608
HashMap 遍历从大的方向来说，可分为4类： 迭代器（Iterator）方式遍历 For Each 方式遍历 Lambda 表达式遍历（JDK 1.8+） Streams API 遍历（JDK 1.8+） 但每种类型下又有不同的实现方式，因此根据具体的遍历方式又可以分为以下7种： 使用迭代器（Iterator）EntrySet 的方式进行遍历 // 创建并赋值 HashMap Map<Integer, String> map = new HashMap(); map.put(1, "
Java之hashMap遍历方式
m0_67401545的博客
06-05 226
在java开发中，hashMap是非常重要的容器类，存储的是键值对(key，value)。 HashMap继承AbstractMap，实现了Map、Cloneable、Serializable接口，非线程安全类，但是效率高。HashMap允许null健和null值，允许value重复，但不允许key重复。HashMap有两个参数影响其性能，初始容量和加载因子，当哈希表中的条目数超出加载因子与当前容量的乘积时，要对哈希表进行refresh操作，重建内部数据结构，容量扩大为之前的两倍，加载因子默认值为0.75。
如何遍历map对象
cxmscb的博客
03-02 730
HashMap遍历在Java中有多种遍历HashMAp的方法。让我们回顾一下最常见的方法和它们各自的优缺点。由于所有的Map都实现了Map接口，所以接下来方法适用于所有Map（如：HaspMap，TreeMap,LinkedMap,HashTable,etc）方法#1 使用For-Each迭代entries这是最常见的方法，并在大多数情况下更可取的。当你在循环中需要使用Map的键和值时，就可以使用这
Java 中HashMap 的几种遍历方式以及遍历速度
最新发布
pige666的博客
10-14 234
Stream 更适合大规模并行处理场景，而在小规模数据或常规使用场景下，entrySet()方式依然是最快的选择。
Java HashMap遍历例子
www.v5qq.com的技术博客
05-09 92
package sn.len.demo; import java.util.HashMap; import java.util.Iterator; import java.util.Map; //HashMap推荐使用这种遍历方法，因为效率相对较高。HashTable也类似 public class DemoList { @SuppressWarnings({ "rawtypes",...
转]Java中HashMap遍历的两种方式
小虫
02-22 618
[转]Java中HashMap遍历的两种方式 原文地址: http://www.javaweb.cc/language/java/032291.shtml 第一种: 　　Map map = new HashMap(); 　　Iterator iter = map.entrySet().iterator(); 　　while (iter.hasNext()) { 　　Map.Entr
java中HashMap遍历方法
剑客阿飞的专栏
12-03 7234
 在java中使用HashMap是主要有两种遍历方法，代码如下：第一种：HashMap hashmap = new HashMap();Iterator iterator = hashmap.keySet().iterator();while (iterator.hasNext()) {       Object value = hashmap.get(iterator.n
Java HashMap 如何正确遍历并删除元素的方法小结
08-25
Java HashMap 遍历和删除元素方法小结 Java HashMap 是一种常用的数据结构，用于存储键值对儿，但是在遍历和删除元素时，需要注意一些特殊的情况，否则可能会出现异常或错误。本文将介绍 Java HashMap 遍历和删除...
Java HashMap遍历删除
z_z
10-12 1394
map的迭代删除，和我们常见的list，set不太一样，不能直接获取Iteraotr对象，提供的删除方法也是单个的，根据key进行删除，如果我们有个需求，将map中满足某些条件的元素删除掉，要怎么做呢？ 首先初始化一个HashMap Map<String, Integer> map = new HashMap<>(); map.put("a", 1); map.put("b", 2); map.put("c", 3); map.put("d", 4); 非常不优雅版本 List&l
基于HashMap遍历和使用方法(详解)
08-29
HashMap遍历和使用方法详解 HashMap是Java中一种常用的数据结构，用于存储键值对的集合。它实现了Map接口，是基于哈希表结构的，可以快速地存储和检索数据。本文将详细介绍HashMap的遍历和使用方法，并比较HashMap...
如何遍历 HashMap，遍历HashMap 的 5 种最佳方式
飞熊的博客
10-18 2830
在本文中，我们将通过示例讨论在 Java 上遍历 HashMap 的五种最佳方法。 使用 Iterator 遍历 HashMap EntrySet 使用 Iterator 遍历 HashMap KeySet 使用 For-each 循环迭代 HashMap 使用 Lambda 表达式遍历 HashMap 使用 Stream API 遍历 HashMap 1. 使用 Iterator 遍历 HashMap EntrySet packagecom.ja..
Java HashMap 遍历方式性能探讨
JAVA高级架构
08-15 362
关注一下又不会怀孕！关于HashMap的实现这里就不展开了，具体可以参考JDK7与JDK8中HashMap的实现JDK8之前，可以使用keySet或者entrySet来...
Java 遍历HashMap详解
weixin_44362355的博客
12-02 391
Java 遍历HashMap详解 遍历KeySet() //遍历hashmap的keySet HashMap<String, Object> mapForKey = new HashMap<>(); mapForKey.put("1",1); mapForKey.put("2",2); mapForKey.put("3",3); mapForKey.put("4",4); Set&lt
Java 基础——HashMap 遍历方式
代码星辰的博客
03-30 2316
本文介绍了 HashMap 几种常用的遍历方式。
Java HashMap遍历的两种方式
weixin_34405557的博客
12-24 111
今天来搞一次HashMap 遍历的操作方式: 经过测试,方式一的效率要远高于方式二.,1000000条测试数据,第一种大概耗时20多秒,第二种耗时大概40多秒.所以,建议以后使用第一种方式. 直接上代码: import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.ut...
map遍历方法（转）
xj8844的博客
11-16 136
　第一种: 　　Map map = new HashMap(); 　　Iterator iter = map.entrySet().iterator(); 　　while (iter.hasNext()) { 　　Map.Entry entry = (Map.Entry) iter.next(); 　　Object key = entry.getKey(); 　　Object val = entr...
Java中hashmap遍历
weixin_43846505的博客
06-04 160
Map的四种遍历方式 下面只是简单介绍各种遍历示例(以HashMap为例)， (1) for each map.entrySet() Map<String, String> map = new HashMap<String, String>(); for (Entry<String, String> entry : map.entrySet()) { ent...
Java HashMap遍历效率比较
"HashMap遍历是Java编程中常见的操作，主要涉及到对HashMap对象的键值对进行访问和处理。本文将探讨如何在Java中有效地遍历HashMap，以及不同遍历方式的性能差异。" 在Java中，HashMap是一种常用的存储键值对的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值