HashMap1.8深度解析

最新推荐文章于 2023-02-22 15:18:22 发布
最新推荐文章于 2023-02-22 15:18:22 发布
阅读量257 收藏 1
点赞数
分类专栏： javaSE 文章标签： hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p874593785/article/details/119144593
版权

什么是HashMap?

百度百科：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）

HashMap各个参数的作用

//默认初始化容量 1往右移4
//0000 0001-->0001 0000; 10000转二进制=16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量 1往右移30 =2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认加载因子0.75，用途是当存储容量到达75%时进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树阈值 当该阈值>=8时将会由链表转红黑树
static final int TREEIFY_THRESHOLD = 8;
//非树阈值 当该阈值<=6时，由红黑树转链表
static final int UNTREEIFY_THRESHOLD = 6;
//最小树容量，表示当数组容量至少存储了64个以后才能转红黑树
static final int MIN_TREEIFY_CAPACITY = 64;

//当前数组存储的数量

transient int size;

//修改次数，目的是为了防止在get的同时进行put操作

transient int modCount;

//扩容阈值 resize (capacity * load factor)

int threshold;

//加载因子

float loadFactor;

//Node节点，为链表

static class Node<K,V> implements Map.Entry<K,V> {

    final int hash;

    final K key;

    V value;

    Node<K,V> next;



    Node(int hash, K key, V value, Node<K,V> next) {

        this.hash = hash;

        this.key = key;

        this.value = value;

        this.next = next;

    }



    public final K getKey()        { return key; }

    public final V getValue()      { return value; }

    public final String toString() { return key + "=" + value; }

    public final int hashCode() {

        return Objects.hashCode(key) ^ Objects.hashCode(value);

    }

    public final V setValue(V newValue) {

        V oldValue = value;

        value = newValue;

        return oldValue;

    }



    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的hash方法

//根据key的hashCode值计算HashMap的hash值

static final int hash(Object key) {

    int h;

    //如果当前key==null，那么hash值为0

    //h ^ (h >>> 16)

    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

HashMap获取数组Node节点

//获取链表

final Node<K,V> getNode(int hash, Object key) {

    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

    //table不为空且table长度大于0且获取的链表也不为空

    if ((tab = table) != null && (n = tab.length) > 0 &&

            (first = tab[(n - 1) & hash]) != null) {

        //判断当前的链表hash+equals是否匹配，匹配返回当前Node节点

        if (first.hash == hash && // always check first node

                ((k = first.key) == key || (key != null && key.equals(k))))

            return first;

        //若是不匹配，则轮询查找

        if ((e = first.next) != null) {

            //若当前node节点为红黑树，根据红黑树的查找方式获取TreeNode

            if (first instanceof TreeNode)

                return ((TreeNode<K,V>)first).getTreeNode(hash, key);

            //否则轮询查找获取该Node节点

            do {

                if (e.hash == hash &&

                        ((k = e.key) == key || (key != null && key.equals(k))))

                    return e;

            } while ((e = e.next) != null);

        }

    }

    return null;

}

HashMap初始化

//HashMap有参构造函数

public MyHashMap(int initialCapacity, float loadFactor) {

    //若初始化容量<0 报错

    if (initialCapacity < 0)

        throw new IllegalArgumentException("Illegal initial capacity: " +

                initialCapacity);

    //若初始化容量>设定的最大容量，初始化容量=最大容量

    if (initialCapacity > MAXIMUM_CAPACITY)

        initialCapacity = MAXIMUM_CAPACITY;

    //若加载因子<=0，或加载因子不为数值，报错

    if (loadFactor <= 0 || Float.isNaN(loadFactor))

        throw new IllegalArgumentException("Illegal load factor: " +

                loadFactor);

    this.loadFactor = loadFactor;

    this.threshold = tableSizeFor(initialCapacity);

}

HashMap的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;

    //若数组为空或者数组长度为0，进行扩容

    if ((tab = table) == null || (n = tab.length) == 0)

        //扩容后赋值当前table长度给n

        n = (tab = resize()).length;

    //若是利用(n-1) & hash获取table的i，获取table[i]判断node是否为空，为空就创建一个新node给该table[i]

    if ((p = tab[i = (n - 1) & hash]) == null)

        tab[i] = newNode(hash, key, value, null);

    else {

        //否则就进行追加

        Node<K,V> e; K k;

        //判断当前node节点的key.hash+equals是否匹配

        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循环判断node节点next是否为空，为空则追加。此法为尾插法

            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

                        //若是当前节点数已经大于等于7，-1是因为去除了第一个。实际上是大于等于8

                        //转红黑树

                        treeifyBin(tab, hash);

                    break;

                }

                //若是能找到该key匹配的node节点，也停止查找，稍后将赋值新value

                if (e.hash == hash &&

                        ((k = e.key) == key || (key != null && key.equals(k))))

                    break;

                p = e;

            }

        }

        //若e为空，说明p.next是新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;

}
final void treeifyBin(Node<K,V>[] tab, int hash) {

    int n, index; Node<K,V> e;

    //若当前table数量<64，则扩容但不转红黑树

    //即转红黑树的条件为table数>=64，且该链表>=8才符合要求

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

        resize();

    else if ((e = tab[index = (n - 1) & hash]) != null) {

        //若该node节点不为空，则走该分支。其实已经确认过。

        //转红黑树

        TreeNode<K,V> hd = null, tl = null;

        do {

            TreeNode<K,V> p = replacementTreeNode(e, null);

            if (tl == null)

                hd = p;

            else {

                p.prev = tl;

                tl.next = p;

            }

            tl = p;

        } while ((e = e.next) != null);

        if ((tab[index] = hd) != null)

            hd.treeify(tab);

    }

}

HashMap的get

//get方法

public V get(Object key) {

    Node<K,V> e;

    //根据当前key计算出hash值，并利用getNode方法比较hash+equals方法获取value

    return (e = getNode(hash(key), key)) == null ? null : e.value;

}

HashMap扩容

final Node<K,V>[] resize() {

    Node<K,V>[] oldTab = table;

    //oldCap=table长度，oldThr = 阈值

    int oldCap = (oldTab == null) ? 0 : oldTab.length;

    int oldThr = threshold;

    int newCap, newThr = 0;

    if (oldCap > 0) {

        //若旧table长度已经到达最大容量

        if (oldCap >= MAXIMUM_CAPACITY) {

            //阈值为integer最大值

            threshold = Integer.MAX_VALUE;

            return oldTab;

        }

        //oldCap左移1位，也就是2倍

        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

                oldCap >= DEFAULT_INITIAL_CAPACITY)

            //新阈值=旧阈值的2倍

            newThr = oldThr << 1; // double threshold

    }

    else if (oldThr > 0) // initial capacity was placed in threshold

        //若table长度为0，阈值大于0，把阈值赋值给新table长度

        newCap = oldThr;

    else {               // zero initial threshold signifies using defaults

        //新table长度为默认长度 16

        newCap = DEFAULT_INITIAL_CAPACITY;

        //新阈值=默认加载因子0.75 * 默认长度16

        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

    }

    if (newThr == 0) {

        //生成新阈值

        float ft = (float)newCap * loadFactor;

        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

                (int)ft : Integer.MAX_VALUE);

    }

    threshold = newThr;

    @SuppressWarnings({"rawtypes","unchecked"})

    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

    table = newTab;

    //扩容时将旧table中的数据移动到新table中

    if (oldTab != null) {

        for (int j = 0; j < oldCap; ++j) {

            Node<K,V> e;

            //将oldTable对应的链表赋值给e,并将oldTable对应的index清空，为了垃圾回收

            if ((e = oldTab[j]) != null) {

                oldTab[j] = null;

                //若e.next为空,说明当前链表只有一个node

                if (e.next == null)

                    //将e赋值给新table对应的index

                    newTab[e.hash & (newCap - 1)] = e;

                else if (e instanceof TreeNode)

                    //判断e是否为红黑树，若是即按照红黑树的情况来增加元素

                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

                else { // preserve order

                    //否则使用高低node节点来拆分链表

                    //低头链表node

                    Node<K,V> loHead = null, loTail = null;

                    //高头链表node

                    Node<K,V> hiHead = null, hiTail = null;

                    Node<K,V> next;

                    do {

                        next = e.next;

                        //利用hash & 旧table长度判断是否==0

                        //注：我们知道hash & (length -1)是为了均匀存放key

                        // 那么 hash & length就只有两个结果，要么0，要么当前table长度

                        //举个例子： 1: 0000 0001   1&16=0

                        //          2: 0000 0010   2&16=0

                        //          3: 0000 0011   3&16=0

                        //         17: 0001 0001   17&16=16

                        //         16: 0001 0000

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

                    //高低链表二者用的都是尾插法

                    //低链表为新table[index]原链表

                    if (loTail != null) {

                        loTail.next = null;

                        newTab[j] = loHead;

                    }

                    //高链表为新table[index+ oldTable长度]新链表

                    //为何是j+oldCap，因为每次扩容都是2倍，这样的话就直接分摊了2个链表，又避免了1.7死循环的bug

                    if (hiTail != null) {

                        hiTail.next = null;

                        newTab[j + oldCap] = hiHead;

                    }

                }

            }

        }

    }

    return newTab;

}

删除HashMap元素

public V remove(Object key) {

    Node<K,V> e;

    //删除

    return (e = removeNode(hash(key), key, null, false, true)) == null ?

            null : e.value;

}

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;

        //根据hash查找链表

        if (p.hash == hash &&

                ((k = p.key) == key || (key != null && key.equals(k))))

            //根据hash+equals获取node

            node = p;

        else if ((e = p.next) != null) {

            if (p instanceof TreeNode)

                //若为红黑树，按照红黑树的规则获取node

                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);

            else {

                //该节点找不到，则轮询next

                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)

                //若当前node是头节点，那么头结点的next为table[index]

                tab[index] = node.next;

            else

                //此时p为node的上一个节点，p.next=node.next。正好去除该node

                p.next = node.next;

            //++修改次数

            ++modCount;

            //--数组容量

            --size;

            afterNodeRemoval(node);

            return node;

        }

    }

    return null;

}

public void clear() {

    //清除，每个table对应的链表置为空

    Node<K,V>[] tab;

    modCount++;

    if ((tab = table) != null && size > 0) {

        size = 0;

        for (int i = 0; i < tab.length; ++i)

            tab[i] = null;

    }

}

HashMap1.7与1.8的区别

  1. 初始值容量改成1 << 4，扩容改成newCap = oldCap << 1，目的在于使用二进制计算更快
  2. 解决了扩容死锁的问题，并且利用高低链表的方式，快速拆分链表并存入新的链表。而且增加了红黑树，解决链表过程时间复杂度高的情况。1.7使用的是头插法，而1.8使用的是尾插法
  3. 在写法上，1.8比1.7的代码水平提高了档次。

Java程序员张同学
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合框架系列 Map（十）：HashMap 1.8
windy杨树的博客
03-18 464
目录 1 概述 2 原理 3 源码分析 　3.1 构造方法 　　3.1.1 构造方法分析 　　3.1.2 初始容量、负载因子、阈值 　3.2 查找 　3.3 遍历 　3.4 插入 　　3.4.1 插入逻辑分析 　　3.4.2 扩容机制 　　3.4.3 链表树化、红黑树链化与拆分 　3.5 删除 　3.6 其他细节 　3.7 总结 1. 概述 本篇文章我们来聊聊大家日常开发中常用的一个集合...
Java集合：HashMap详解（JDK 1.8）
qq_40285302的博客
09-07 585
概述 JDK 1.8对HashMap进行了比较大的优化，底层实现由之前的“数组+链表”改为“数组+链表+红黑树”，本文就HashMap的几个常用的重要方法和JDK 1.8之前的死循环问题展开学习讨论。JDK 1.8的HashMap的数据结构如下图所示，当链表节点较少时仍然是以链表存在，当链表节点较多时（大于8）会转为红黑树。 本文地址：http://blog.csdn.net/v12341...
HashMap 1.8
m0_68927002的博客
07-10 489
HashMap 1.8
HashMap1.8
java_eehehe的博客
03-05 377
HashMap1.8 Java8 对 HashMap 进行了一些修改，最大的不同就是利用了红黑树，所以其由 数组+链表+红黑树 组成。根据 Java7 HashMap 的介绍，我们知道，查找的时候，根据 hash 值我们能够快速定位到数组的具体下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的，时间复杂度取决于链表的长度，为 O(n)。为了降低这部分的开销，在 Java8 中，当链表...
hashMap1.8源码
01-19
HashMap是Java编程语言中最常用的集合类之一，它提供了一种基于键值对（key-value pair）的数据存储方式，具有高效查找、插入和删除操作。在Java 8中，HashMap的实现有了很多改进，以提高性能和空间利用率。下面我们...
Jdk1.8 HashMap实现原理详细介绍
08-31
在JDK 1.8中，HashMap的实现有了重大的改进，尤其是在处理哈希碰撞方面。以下是对JDK 1.8 HashMap实现原理的详细解释。 首先，HashMap是一个基于哈希表的数据结构，它实现了Map接口。它不保证映射的顺序，并且是非...
HashMap源码深度剖析.md
03-29
HashMap源码深度剖析，面试必备
HashMap jdk1.8源码阅读.md
02-17
本人源码阅读理解， 基于jdk1.7 和jdk 1.8的java HashMap源码的理解， 希望对你理解java源码有作用
HashMap之resize()方法源码解读.docx
06-17
HashMap之resize()方法源码解读 HashMap的resize()方法是HashMap中最核心的方法之一，该方法负责扩容HashMap的容量，以便存储更多的键值对。下面我们将对HashMap的resize()方法进行源码解读，了解其扩容机制和原理...
hashmap(1.8)
weixin_33889245的博客
05-22 126
平常开发过程中hashmap初始化大小设置：（预计数据量的1.34倍 -> 再向上找最小的2的n次幂） 　　某个Map存储了10000个数据，那么他会扩容到 20000，实际上，根本不用 20000，只需要 10000* 1.34= 13400 个，然后向上找到一个2 的幂次方，也就是 16384 初始容量足够（也可以直接写13400，因为hashmap构造函数回自动计算大于等于1340...
jdk1.8中HashMap
rj2017211811的博客
10-20 152
jdk1.8中底层数据结构使用数组+链表+红黑树 查看源码定义 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { private static final long serialVersionUID = 362498820763181265L; /** * The default initi
Java基础-Hashmap1.8
阳光码术-Java面试宝典
01-27 578
JDK1.8的HashMap数据结构和原理[面试9.9]? 数据结构?数组+链表+红黑树数组?空间连续,查询快,但是插入和删除较慢,因为要移动元素链表?增加删除快,因为是内存地址指针,查找慢,因为需要按顺序依次查询红黑树: 一种平衡的二叉树,以O(log2(n))的时间复杂度进行搜索,插入,删除等操作hashmap数据结构-原理hashmap1.8数据结构-视频key是怎么进行hash运算的?若key为空直接返回0若key不为空才进行运算,key取hashCode的值(32位)向右移16位得到的值和该h
Java集合------HashMap(1.8)
剑小纯的夜话白鹭
03-27 667
Java集合------HashMap(1.8) 前言 在之前的博文中,我们对JDK1.7中的HashMap源码进行了分析,在JDK1.8以后,HashMap又进行了一些优化.为什么要优化呢? 其实很明显的一个地方就是: 当Hash冲突严重时,在桶上形成的链表就会越来越长,这样在查询的时候效率就会越来越低;时间复杂度为O(N). 下面我们就来看看在java1.8中,HashMap是怎么进行优化...
HashMap(JDK1.8)源码+底层数据结构分析
最新发布
早睡早起的博客
02-22 1077
Hash Map源码分析
Java重点源码回顾——HashMap1.8
XHHP
12-30 1037
在之前的文章中，我们介绍了HashMap1.7的源码，今天我们来看下HashMap1.8的源码。HashMap1.8相比于1.7最大的改变就是改变了1.7中采用数组+链表的方式存储键值对，转而由数组+链表+红黑树的方式来存储键值对。HashMap1.8的底层结构如下图所示：当链表中结点数较少（小于8）的时候，还是采用数组+链表的方式。当链表中结点过多，就会造成查找效率低下的情况，就会转而采用数组+红黑树的方式。
hashMap源码分析1.8
weixin_40245787的博客
01-07 865
HashMap JDK1.8的HashMap：底层实现（数组+链表/红黑树） 1、为什么要从JDK1.8之前的链表设计，修改为链表或红黑树的设计？ 当某个链表比较长的时候，查找效率还是会降低。 为了提高查询效率，那么把table[index]下面的链表做调整。 如果table[index]的链表的节点的个数比较少，（8个或以内），就保持链表。如果超过8个，那么就要考虑把链表转为一棵红黑树。 T...
JDK1.8 HashMap
牧码人
01-17 226
人狠话不多，菜就完了! public static void main(String[] args) { HashMap<String, Object> hashMap = new HashMap<>(); hashMap.put("1", "A"); hashMap.put("1", "B"); hashMap.put("2", "C"); System.out.println(hashMap.get("1")); } HashMap中定义
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值