HashMap源码分析

最新推荐文章于 2023-03-27 17:08:56 发布
最新推荐文章于 2023-03-27 17:08:56 发布
阅读量366 收藏
点赞数
分类专栏： java 文章标签： 源码 hashmap hashcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bell10027/article/details/50301491
版权

最近看见不少文章提到HashMap 源码， 这里就来具体分析一下HashMap源码

首先HashMap 继承自AbstractMap

public final int hashCode() {
     return Objects.hashCode(key)^Objects.hashCode(value);
}

当然还有equals方法

    public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }

接着是HashMap的构造方法

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

参数很简单，初始容量，和加载因子。初始容量定义了初识数组的大小，加载因子和初始容量的乘积确定了一个阈值。阈值最大是(1<<30) + 1。初始容量一定是2的N次方，而且刚刚比要设置的值大。默认初始容量是16，默认加载因子是0.75。当表中的元素数量大于等于阈值时，数组的容量会翻倍，并重新插入元素到新的数组中，由于数组长度发生了改变,所以元素的位置肯定发生变化 所以HashMap不保证顺序恒久不变。当输入的加载因子小于零或者不是浮点数时会抛出异常（IllegalArgumentException）。

接下来是put操作：

putAll:
putAll 方法里面是调用 putMapEntries 来完成put操作的

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

可知,上述方法主要是对传入的map进行遍历,在for方法中调用putVal方法来存入数据

putVal():

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

这个是8.0的代码,貌似在7.0的基础上做了一些修改,首先,如果当前tab是空的话就对它进行初始化,这里初始化大小用到了resize()方法，可以看出resize()方法在这里不止用于当元素达到阈值的时候双倍当前数组的大小,还兼备了初始化的功能，接下来,如果当前hash值所在的位置如果为空,就新创建一个节点newNode(hash,key,value,null);之后就是正常的处理,如果当前hash所在位置有值,且key值相同,就直接替换,如果key值不相同就在当前节点.next 节点来创建,最后通过判断e是否为空来取得oldValue 还有通过判断 binCount 是否大于阈值
当符合(p instanceof TreeNode)这个条件的时候，把链表变成treemap，这样查找效率从o(n)变成了o(log n) 还有原先resize()方法里的transfer方法也没有了,直接合并到resize方法中去了.

添加Node：
添加Node：

图片来自：http://androidperformance.com/2015/08/05/HashMap.html

containsValue相对来说没有什么变化,都是遍历数组取值比较,remove相对做了removeTreeNode的流程,跟put一样get也与之前差不多,没有进行什么特别的算法优化,

 final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

removeNode:

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

可见 removeNode与PutVal方法结构上十分相近,在这里不赘述

另外

 public Set<K> keySet() {
        Set<K> ks;
        return (ks = keySet) == null ? (keySet = new KeySet()) : 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 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();
            }
        }
    }
  --------
    public Collection<V> values() {
        Collection<V> vs;
        return (vs = values) == null ? (values = new Values()) : vs;
    }

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

返回集合的方法大体结构都是通过构造内部类的方法来返回的 example: keyset ,values Entrykey

暂时就这样。。。

katsueiki
关注
专栏目录
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 972
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
HashMap源码分析(超级详细)
V539413949的博客
04-14 672
1.HashMap简介 HashMap基于哈希表的Map接口实现，是以key-value存储形式存在。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。) 1.2 HashMap数据结构 在 JDK1.8 中，HashMap 是由 数组+链表+红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。当一个值中要存储到Map的时候会根据Key的值来计算出他的 hash，通过哈希来确认到数组的位置，如果发生哈希碰撞就以链表的形式存储 在Objec
HashMap 源码分析
搬运Gong
04-03 609
HashMap 源码分析，动态扩容以及链表、红黑树之间的转换过程
java HashMap 源码分析（深度讲解）
Cyan_RA9的博客
03-27 1644
java 集合篇章——HashMap源码分析（非常详细）。
Rust HashMap 源码分析
今天你emo了吗？
06-03 725
Rust HashMap 源码分析1 HashMap 数据结构 1 HashMap 数据结构 use hashbrown::hash_map as base; #[derive(Clone)] pub struct RandomState { k0: u64, k1: u64, } pub struct HashMap<K, V, S = RandomState> { base: base::HashMap<K, V, S>, } HashMap 有三个
HashMap 源码分析1.8
weixin_45706854的博客
06-26 852
HashMap 源码分析 简介 HashMap 是 Java 语言中常用的用于存放键值对数据类型的集合类。 随着 JDK（Java Developmet Kit）版本的更新，JDK 1.8 对 HashMap 底层的实现进行了优化，底层实现也由之前的 数组 + 链表 改为 数组 + 链表 + 红黑树 。 HashMap 的常用方法如下： //创建一个 map Map<String, String> map = new HashMap<>(); //如果 key 不存在则插入数据，如
【数据结构-源码分析】HashMap源码分析(超级详细）
fearless的博客
01-03 1391
HashMap基于哈希表的Map接口实现，是以key-value存储形式存在。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同)。在 JDK1.8 中，HashMap 是由数组 + 链表 + 红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。当一个值中要存储到Map的时候会根据Key的值来计算出他的hash，通过哈希来确认到数组的位置，如果发生哈希碰撞就以链表的形式存储。当链表长度过长时，HashMap会把这个链表转换成红黑树来存储。
HashMap 源码分析(JDK1.8)
huangshanchun的专栏
12-30 1167
HashMap是Java程序员使用频率最高的容器之一，主要原因它的查询效率比较高，本文基于JDK1.8，深入探讨HashMap的结构实现和功能原理。
Java HashMap 源码分析
BusyMonkey
07-17 994
https://www.cnblogs.com/chengxiao/p/6059914.html   哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原...
如何修改java String
geyingqiの博客
03-07 1057
众所周知，String 类是不可变对象，那么是否有方法改变它呢？String的成员变量都是private final的，即为初始化之后不可改变，但是其中value比较特殊，因为它是一个引用变量，value是final修饰的，也就是说final不能再指向其他数组对象，既然改变value指针的指向不可能，那么能否改变value指向的数组元素吗？比如改变数组中的s,使其变成n，由于String中的所有成员
SystemClock.sleep
geyingqiの博客
12-18 922
偶然在有关线程池的一篇博客中看见了这个方法,不理解与Thread.sleep()方法的区别是什么,于是做此笔记. SystemClock.sleep(millis) is a utility function very similar to Thread.sleep(millis), but it ignores InterruptedException. Use this function f
java aio
geyingqiの博客
12-17 757
简介java AIO（NIO.2）:异步非阻塞,服务器的实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。适用场景AIO方式适用于链接数目比较多且比较长的架构(重操作)比如相册服务器,充分调用OS参与并发操作,编程比较复杂,jdk7开始支持详解所谓AIO 异步io,主要是针对线程在调用IO获取外部数据的时候,是否阻塞调用线程来说的，一般调用步骤大
算法
geyingqiの博客
12-18 499
实现一个可以得到最小值的栈这里首先要创建两个栈对象,其中一个正常进行栈的相关数据结构,第二个栈在push的时候需要与当前栈的栈顶元素进行比较,如果大于或者等于当前栈元素的话就重新push一个当前栈顶元素,这样可以保证第二个栈的栈顶元素是整个栈元素中最小的,即可求出最小值判断当前字符串与另一个字符串是否为旋转词假设有s1 = “1234” 那么他的旋转词为”2341”，”3421”，”4123”三种,
前端初始化资源包初始化前端
10-01
.....................
vmware ubuntu22.04安装教程.docx
最新发布
10-01
vmware ubuntu22.04安装教程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值