我所理解的JDK集合类（二）：从源码分析HashMap的遍历方式

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量74 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/3466682/blog/1575685
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

上一篇文章简单的写过了HashMap的工作原理。接下来从JDK1.8的源码的角度来分析一下HashMap的遍历方式。

1，使用keySet遍历，使用map.get(key)获取value

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

keySet()方法返回的是一个new KeySet()。而KeySet是HashMap的一个内部类

    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 removeNode(hash(key), key, null, false, true) != null;
        }
        public final Spliterator<K> spliterator() { // JDK1.8新增，方便Stream流式API操作
            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super K> action) { // JDK1.8新增，方便lambda形式遍历
            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继承自AbstractSet。AbstractSet定义了hashCode()和equals()方法，调用iterator()实现了removeAll()方法。AbstractSet继承了AbstractCollection，AbstractCollection定义了集合类操作的一些基本方法，比如toArray()，contains(e)，remove(e)等等。 几乎所有的Set接口的实现类都是继承自AbstractSet。

而Set类的遍历方法，无非就是for循环、foreach、iterator三种。for循环需要的是size()，源码已有。foreach内部实现还是调用了iterator的hasNext()和next()。而iterator()从源码上看返回的是HashMap的内部类KeyIterator。来分析一下KeyIterator的源码：

    final class KeyIterator extends HashIterator
        implements Iterator<K> {
        public final K next() { return nextNode().key; }
    }

这里有引入了nextNode()方法。nextNode()是其父类HashIterator的方法。HashIterator是HashMap的一个内部类。HashMap内部的EntryIterator、KeyIterator、ValueIterator都继承自HashIterator。

    abstract class HashIterator {
        Node<K,V> next;        // 下一次要返回的节点
        Node<K,V> current;     // 当前已经返回的节点
        int expectedModCount;  // 检查符，参考上一边文章提到的ConcurrentModificationException
        int index;             // 当前hash表数组的索引值

        HashIterator() {
            expectedModCount = modCount; // 初始赋值，将HashMap的modCount赋值给自己
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            if (t != null && size > 0) { // 寻找都第一个节点
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            if (modCount != expectedModCount)  // 检查遍历期间是否被意外增添元素
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            if ((next = (current = e).next) == null && (t = table) != null) { // 确定下一个返回的next节点
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount) // 检查遍历期间是否被意外增添元素
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false); // 调用HashMap的removeNode()删除元素
            expectedModCount = modCount; //  removeNode()改变了modeCount的值再次赋给自己
        }
    }

以上分析可见，使用keySet()方便返回keySet来进行遍历，其实是通过调用iterator()返回的节点的key。
顺便看一下EntryIterator、ValueIterator的源码：

    final class ValueIterator extends HashIterator
        implements Iterator<V> {
        public final V next() { return nextNode().value; }
    }

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

可见，这三个的遍历其实都是使用了nextNode()也就是node节点遍历。

2，使用EntrySet遍历。使用entry.getKey()和entry.getValue()来获取key和value。
来看一下entrySet()的源码：

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

这里引入了 new EntrySet()。EntrySet是HashMap的一个内部类。来看一下EntrySet()的源码。

    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() { // JDK1.8新增，方便Stream流式API操作
            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) { // JDK1.8新增，方便lambda表达式遍历
            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();
            }
        }
    }

通过对之前的KeySet的分析，这段EntrySet代码的关键部分在于iterator()中引入的new EntryIterator()。而在分析KeyIterator的最后面已经引入过了EntryIterator的源码。如此的简单：

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

接下来就剩唯一一个没有看到源码的了，Map.Entry。HashMap在内部类EntryIterator中定义了内部类Entry，实现了Map.Entry接口。先来看看Map.Entry的源码：

    interface Entry<K,V> {
        K getKey();
        V getValue();
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
        // 还有JDK1.8新增的public static 的comparingByXxx的方法
    }

这个Map.Entry接口的方法从方法名就知道是要干什么的。而EntryIterator中定义了内部类Entry只是实现了相关方法的具体实现而已。由于本文想阐述HashMap的遍历，就不再分析EntryIterator中定义了内部类Entry的实现源码了。以后有机会的再单独介绍HashMap整体的原理吧。

3，使用values()。由于这种方式只能得到value，不能得到key。严格意义上不能算作HashMap的遍历。
通过对keySet()的分析，很容易就能理解values()的源码：

    public Collection<V> values() {
        Collection<V> vs = values;
        if (vs == null) {
            vs = new Values();
            values = vs;
        }
        return vs;
    }

Values是HashMap的内部类，源码：

    final class Values extends AbstractCollection<V> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<V> iterator()     { return new ValueIterator(); }
        public final boolean contains(Object o) { return containsValue(o); }
        public final Spliterator<V> spliterator() {
            return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? 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.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

4，使用JDK1.8新增的Map.foreach()。源码：

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // 这个异常通常意味着这个entry已不在当前的map中
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

这种形式的遍历从源码很明白的看出使用的是entrySet()进行遍历的。这种形式的遍历通常是配合lambda表达式或者Stream流操作进行函数式遍历。

结论：
　　至此，最根本的两种HashMap的遍历方式的源码都已经很清楚了，有关遍历的效率的结论也很明显：使用entrySet()后entry.getKey()和entry.getValue()是最有效率的遍历。如果只需要遍历key，那使用keySet()也可。如果只需要遍历value，那是用values()就挺好。

转载于:https://my.oschina.net/u/3466682/blog/1575685

weixin_33859844
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Enumeration和Iterator遍历集合类详解
09-05
首先，`Enumeration` 是早期Java版本（JDK 1.0）中引入的接口，主要用于遍历 `Vector`、`Hashtable` 等旧版集合类。`Enumeration` 提供了两个基本方法：`hasMoreElements()` 和 `nextElement()`，分别用于检查是否...
总结Java集合类操作优化经验
09-03
这篇文章将深入探讨Java集合类的操作优化经验，特别是在JDK7环境下。 首先，我们要理解Java集合框架的基础，即`Collection`接口。它是所有集合类型的根接口，表示一组对象，即元素。`Collection`接口提供了基础的增...
Collection集合迭代器iterator遍历集合元素的过程及源码分析
sun10367的博客
07-24 524
迭代器是遍历Collection集合的通用方式，任意Collection集合都可以使用迭代器进行遍历，那么每一种集合的自身特性是不同的，也就是存储元素的方式不同，那么是如何做到遍历方式的统一呢，接下来我们分析一下迭代器的源代码。 Collection接口中有一个抽象方法 Iterator<E> iterator()，返回对集合中元素进行迭代（遍历）的迭代器。 java.util.Iterator接口 public interface Iterator<E> { boolean
HashMap源码分析
weixin_40472874的博客
01-13 99
一、HashMap成员变量 //默认初始table大小，16,2的次幂 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //HashMap最大长度2的30次幂 static final int MAXIMUM_CAPACITY = 1 << 30; //默认加载因子 ...
深入扒 HashMap 源码 - 6.4 HashMap 内部类迭代器 HashIterator、KeyIterator、ValueIterator、EntryIterator
evilcry2012的专栏
03-28 525
深入扒 HashMap 源码 - 6.4 HashMap 内部类迭代器 HashIterator、KeyIterator、ValueIterator、EntryIterator 2018年10月01日 13:01:21要努力变成熟的黄小天天阅读数：241 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ocp114/article/det...
HashMap底层实现原理（源码解析）及常见面试题
qq_42922647的博客
07-26 291
hashmap底层是基于数组加链表实现的，数组是主干，链表主要是为了解决hash冲突存在的。我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存Entry对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用...
用java遍历集合计算总价,java常用集合源码分析之ArrayList遍历方式以及效率比较（五）...
weixin_29483853的博客
03-27 383
一、遍历方式ArrayList支持三种遍历方式。1、第一种，随机访问，它是通过索引值去遍历2、第二种，foreach语句3、第三种，Iterator迭代器方式迭代器是一种模式，它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部。二、几种遍历方式效率的比较从实验结果来看，在遍历ArrayLis...
Java集合源码剖析——基于JDK1.8中HashMap的实现原理
热门推荐
胜天半子祁同伟
09-29 1万+
Java集合源码剖析——基于JDK1.8中HashMap的实现原理
JDK1.8源码分析：HashMap
源码之下，了无秘密
02-07 5224
数据结构 在JDK1.8之前，HashMap是基于链式哈希实现的，而在JDK1.8之后，为了提高冲突节点的访问性能，在链式哈希实现的基础上，在哈希表大小超过64时，针对冲突节点链条，如果节点数量超过8个，则升级为红黑树，小于等于6个时，则降级为链表结构。 链式哈希 链式哈希是一个数组结构，数组元素为链表或者红黑树。如下为HashMap的内部数据存储结构，也是链式哈希的实现。其中Node为一...
Java集合- HashMap 的7种遍历方式
jinyangjie的博客
02-02 983
HashMap 遍历从大的方向来说，可分为以下 4 类： 迭代器（Iterator）方式遍历； For Each 方式遍历； Lambda 表达式遍历（JDK 1.8+）; Streams API 遍历（JDK 1.8+）。 但每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为以下 7 种： 使用迭代器（Iterator）EntrySet 的方式进行遍历； 使用迭代器（Iterator）KeySet 的方式进行遍历； 使用 For Each EntrySet 的方式进行遍历； 使用 For E
HashMap遍历 (四种方法+7种实现方式)
LaiLaiPengPeng的博客
03-09 1319
HashMap遍历 (四种方法+7种实现方式) HashMap遍历从大的方向来说，可分为一下4类： 1、迭代器（Iterator）方式； 2、foreach方式； 3、lambda表达式（JDK 1.8+）; 4、Streams API（JDK 1.8+）; 每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为一下7种： 1、使用迭代器（Iterator）EntrySet的方式； 2、使用迭代器（Iterator）KeySet的方式； 3、使用foreach EntrySet的方式； 4、使用fore
终于来了，最全的 HashMap 7 种遍历方式与性能分析
vincent
05-02 7867
随着 JDK 1.8 Streams API 的发布，使得 HashMap 拥有了更多的遍历的方式，但应该选择那种遍历方式？反而成了一个问题。 本文先从 HashMap 的遍历方法讲起，然后再从性能、原理以及安全性等方面，来分析 HashMap 各种遍历方式的优势与不足，本文主要内容如下图所示： HashMap 遍历 HashMap遍历从大的方向来说，可分为以下 4 类： ...
全面解析Java中的HashMap类
09-02
Java中的HashMap类是集合框架中的核心组件之一，它提供了一个键值对（key-value pairs）的存储方式，允许快速查找和插入数据。HashMap基于哈希表数据结构实现，即通过哈希函数将键映射到数组的特定位置，从而实现...
Java 集合中的类关于线程安全
08-31
大部分在JDK 1.2之后引入的集合类，如ArrayList、LinkedList、HashMap、HashSet、TreeMap、TreeSet等，都不是线程安全的。在多线程环境下，如果你需要使用这些类，你需要自己处理线程同步，或者选择线程安全的替代品...
jdk的数据结构分析1
08-08
在计算机科学中，数据结构是组织、存储和处理数据的方式，它们对于高效算法的设计至关重要。在Java的JDK中，提供了多种内置的数据结构，这些数据结构基于不同的设计理念，适用于不同的场景。下面将对标题和描述中...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 625
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 706
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1136
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
jdk 17 hashmap遍历
04-26
可以使用 JDK 8 引入的 forEach 来遍历 HashMap，示例代码如下： ```java Map, String> hashMap = new HashMap(); // 添加元素 hashMap.put(1, "one"); hashMap.put(2, "two"); hashMap.put(3, "three"); // 遍历 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值