对HashMap源码的一些理解

最新推荐文章于 2022-04-18 17:02:16 发布
最新推荐文章于 2022-04-18 17:02:16 发布
阅读量100 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52272771/article/details/114370211
版权

对源码的分析大部分写在代码的注释里。

构造函数

public HashMap() {
	// 只设置了0.75f负载因子
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
// 返回值为2的n次幂
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}
// evict只有在初始化时才为false，其他时候为true。
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);
        }
    }
}

Node和TreeNode的关系

每个node可以是一条链表，整个HashMap有多个node，即数组+链表，之后可以树化
TreeNode和Node的关系：
class TreeNode<K,V> extends LinkedHashMap.Entry<K,V>
class LinkedHashMap.Entry<K,V> extends HashMap.Node<K,V>
class HashMap.Node<K,V> implements Map.Entry<K,V>

resize()方法

final HashMap.Node<K,V>[] resize() {
    // 保存全部结点
    HashMap.Node<K,V>[] oldTab = table;
    // 旧容量即可有多少个Node
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧阈值即容量达到该值时需要扩容
    int oldThr = threshold;
    // 先初始化一个新容量和新阈值
    int newCap, newThr = 0;
    // 旧容量大于0时
    if (oldCap > 0) {
        // oldCap >= 2的30次方，阈值设为2的31次方-1，扩容结束
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 新阈值=旧阈值*2
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // oldCap<=0,oldThr>0,新容量=旧阈值
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    // oldCap<=0,oldThr<=0;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        // 计算新阈值
        float ft = (float)newCap * loadFactor;
        // 判断是使用新阈值还是Integer.MAX_VALUE
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                (int)ft : Integer.MAX_VALUE);
    }
    // 将新阈值设置到HashMap里
    threshold = newThr;
    // 新建一个Node数组，长度为newCap
    @SuppressWarnings({"rawtypes","unchecked"})
    HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
    // 将HashMap的Node数组引用指向新数组
    table = newTab;
    // 如果旧Node数组不为空，复制其数据到新数组
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            HashMap.Node<K,V> e;
            // 把旧数组的Node赋给e，然后判断e是否为空，不为空继续操作
            if ((e = oldTab[j]) != null) {
                // 把旧数组的Node置为空
                oldTab[j] = null;
                // e没有下一个结点时（即某个Node没有链时）
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // e是树结点时（某个Node已树化时）
                else if (e instanceof HashMap.TreeNode)
                    // 拆分树结点
                    ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                // e不为空也不是树结点时（某个Node还是链表时）
                else { // preserve order
                    // 拆分链表结点
                    HashMap.Node<K,V> loHead = null, loTail = null;
                    HashMap.Node<K,V> hiHead = null, hiTail = null;
                    HashMap.Node<K,V> next;
                    do {
                        // next指向e的下个结点
                        next = e.next;
                        // 数组下标的计算方法为(cap - 1) & hash
                        // 原数组下标为(oldCap - 1) & hash(key)
                        // e.hash就是hash(key)得来的
                        // 通过判断(e.hash & oldCap) == 0,
                        // 因为oldCap是2的n次方，例如：10000，所以上面的表达式其实就是判断e的key进行hash之后的值在对应oldCap某位上是否为0，以此为依据将原来的链表分成两条链表，分别是lohead->loTail,liHead->liTail
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // loTail如果为空意味着没有以loHead开头的链表
                    if (loTail != null) {
                        loTail.next = null;
                        // loHead链表放置在新数组的索引：旧索引
                        newTab[j] = loHead;
                    }
                    // hiTail如果为空意味着没有以hiHead开头的链表
                    if (hiTail != null) {
                        hiTail.next = null;
                        // hiHead链表放置在新数组的索引：旧索引+旧容量
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

put()方法

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table为空或者长度为0时，扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 通过(n - 1) & hash计算出索引，判断该索引处是否为空，为空就插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 该索引处不为空，把新Node接到链表或者树的后面去
    else {
        Node<K,V> e; K k;
        // 如果新插入Node与数组的p结点的key的hash值相同并且key的内容相同，那么把原Node赋给e，下面会对该Node的value进行覆盖
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果数组里的p结点时树结点，那么执行putTreeVal
        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);
                    // 如果binCount>=8-1时，即bin中的结点超过8个时执行treeifyBin，判断是否需要树化
                    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;
            }
        }
        // 存在相同的Node，覆盖掉原来的Node，返回原来的Node的value
        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;
}

树化条件

在putVal()方法里：

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    treeifyBin(tab, hash);

在treetreeifyBin()方法里：

if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
    resize();

由此可见，如果要树化，需要bin里的Node个数达到9，并且Node数组长度 >= MIN_TREEIFY_CAPACITY。

没有达到以上条件只会进行扩容。

红黑树退化成链表

树化解除的方法为untreeify()。在split()和removeTreeNode()中都有出现，两个方法中解除树化的条件不一样。

split()中，如果树的大小不足6，就会解除树化，退化为链表。

if (loHead != null) {
    if (lc <= UNTREEIFY_THRESHOLD)
        tab[index] = loHead.untreeify(map);
    else {
        tab[index] = loHead;
        if (hiHead != null) // (else is already treeified)
            loHead.treeify(tab);
    }
}
if (hiHead != null) {
    if (hc <= UNTREEIFY_THRESHOLD)
        tab[index + bit] = hiHead.untreeify(map);
    else {
        tab[index + bit] = hiHead;
        if (loHead != null)
            hiHead.treeify(tab);
    }
}

removeTreeNode()中，树化解除的条件有多种可能：

  • 根结点为空

  • 根结点的右子树为空

  • 根结点的左子树为空

  • 根结点的左子树的左子树为空

if (root == null
    || (movable
            && (root.right == null
    			|| (rl = root.left) == null
    			|| rl.left == null))) {
    tab[index] = first.untreeify(map);  // too small
    return;
}
BLUE SKY!!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
1.6 hashmap源码
02-18
hashmap源码，可以看看http://blog.csdn.net/wabiaozia/article/details/50684556
hashmap源码详解
weixin_44053668的博客
08-01 166
       java语言除了数组外是没有任何现成的数据结构的,所有的数据结构都是jdk类库提供的,哈希表是一种数据结构,这种数据结构要求读写对应的时间复杂度必须为O(1),为了实现这个目的大家看下jdk大佬们是如何实现的吧,以及从jdk1.8只有做了哪些相应的改进. 1.成员变量 // 默认初始容量 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 最大容量 sta
Java8 - HashMap源码
纽西兰牛小扒的博客
09-24 7135
java8 - HashMap源码解析，哈希表与红黑树的结合。
HashMap 源码
男儿当自强
06-01 250
数组长度为2的幂，因为计算数组下标时候用到（数组长度-1）&amp; hash ,2的幂-1对应的高位都变成了0，低位都变成了1，只使用hash的低位做下标，如果整个hash范围（-2^31  2^31-1）全用，数组长度太大。hashcode获取方式 (key == null) ? 0 : (h = key.hashCode()) ^ (h &gt;&gt;&gt; 16) ，可以看到，采用ke...
深入理解Java之HashMap源码剖析
08-31
主要介绍了深入理解Java之HashMap源码剖析，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
HashMap jdk1.8源码阅读.md
02-17
本人源码阅读理解， 基于jdk1.7 和jdk 1.8的java HashMap源码的理解， 希望对你理解java源码有作用
java7hashmap源码-Interview:面试宝典
06-04
hashmap源码 Interview 一、Java基础 String类为什么是final的。 理解final 修辞类，类不能被继承 修辞方法，方法不能被重写 修辞类变量，变量必须初始化 字符串池String Pool 字符串创建方式 String str = ...
java7hashmap源码-AnnotationDemo:注解基础知识，编译时注解和运行时注解例子
06-04
hashmap源码 注解 理解Java注解 注解就相当于对源代码打的标签，给代码打上标签和删除标签对源代码没有任何影响。有的人要说了，你尽几把瞎扯，没有影响，打这些标签干毛线呢？其实不是这些标签自己起了什么作用，...
java7hashmap源码-AndroidOffer:只为帮助您获得更好的报价
06-04
hashmap源码 AndroidOffer Java Java 进阶 HashMap 对比：Hashtable、HashMap、LinkedHashMap、ConcurrentHashMap、TreeMap （看第六条就可以） HashMap 用什么数据结构实现的 加载因子是什么 HashMap 初始化传入的...
HashMap的源码
m0_58011182的博客
04-18 784
解读
终于搞懂HashMap的源码了!!!
weixin_40413961的博客
06-14 646
背景 HashMap是我们在平时开发最常用的容器之一，但是我们有真正了解过他吗？他是线程安全的吗？他是以何种方式来存储的呢？为什么初始化的容器大小时2的n次幂呢？他是如何进行扩容的呢？他是如何实现并发安全呢？等等一系列问题。正是知己知彼才能百战百胜，所以我打算深入理解一下hashMap hashMap脑图 为了理清思路和能快速记住hashMap的“面貌”就大概列了一下 看完脑图，其中很多还是不够详细的。只是概述了内容。 HashMap hashMap的概述 hashMap，继承Map集合，以key-v
HashMap源码分析
和大黄的博客
02-24 8490
1、hashmap的数据结构 要知道hashmap是什么，首先要搞清楚它的数据结构，在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，hashmap也不例外。Hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列“），请看下图（横排表示数组，纵排表示数组元素【实际上是一个链表】）。 上图中，X轴方向为HashMap的数组容器，Y轴方向，为每个相应位置的单向链表。每一个元素都是一个包含如图所示四个属性，k
hashmap源码解读
zyc8715150的博客
04-23 230
hashmap扩容源码解读 一、四个构造行函数 1.设置初始化大小，以及负载因子（threshold（阀值）=initialCapacity*loadFactor） 阀值：超出这个大小则会扩容。 最后，tableSizeFor():找到大于等于initialCapacity，且是2的次方，这个算法还是比较牛逼的，里面的逻辑是，初始化大小减去1，找到最大位数的1，将他无符号向右移动5次，如5，减去...
HashMap源码
大龙的博客
06-10 8960
数组：数组存储区间是连续的，占用内存严重，故空间复杂度很大，但数组的二分查找时间复杂度很小，为 o（1），数组的特点：查找速度快、插入和删除效率低 链表：链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，为 o（n），链表的特点：查找速度慢、插入和删除效率高 哈希表：综合了数组和链表的特性，不仅查找速度快，插入和删除的效率也很高，哈希表有多种不同的实现方式，下面我们就介绍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值