[JDK8] HashMap源码解析

最新推荐文章于 2022-07-16 17:12:36 发布
最新推荐文章于 2022-07-16 17:12:36 发布
阅读量532 收藏 5
点赞数 1
分类专栏： Java源码解析 文章标签： jdk HashMap 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011506951/article/details/106041195
版权

文章标题

写在前面

HashMap的实现思想太有含金量了，方方面面都有值得细细品鉴的，想用一篇文章分析透彻，还是比较难的。

我也就是把这么多年的理解尝试着总结一下，写的仓促，可能有错误的地方，欢迎指正！

底层存储结构

HashMap底层存储结构是数组：

transient Node<K,V>[] table;

Node<K,V>是HashMap中定义的一个节点类，用于存储(key, value)键值对形式的对象：

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
    // 省略其它
}

其中包含四个属性：

  1. key：键值对的key值
  2. value：键值对的value值
  3. hash：key的哈希值，用于计算节点在数组table中的存储位置
  4. next：具有相同hash值的节点，会存储在数组table相同的位置，多个节点之间构成链表，数量超过8个后，转换成红黑树结构

因为数组 + 链表/红黑树这种存储结构就像是一张二维关系表，所以Node<K,V>[]取名table，更能表达存储结构的含义。

构造HashMap

HashMap的构造方法有4个：

public HashMap() {...}
public HashMap(int initialCapacity) {...}
public HashMap(int initialCapacity, float loadFactor) {...}
public HashMap(Map<? extends K, ? extends V> m) {...}

最常用的是前两个构造方法。

第一个没什么好说的，就是一行配置loadFactor默认值的代码。

第二个最有意思，传入了一个构造参数initialCapacity，这个参数是用来设置数组table初始长度的。

说它有意思，是因为initialCapacity参数并不是直接拿来用的，它经过了一次二进制转换，变成了另外一个数值：最接近的但不小于initialCapacity本身的2的幂次方。

tableSizeFor(int cap)

跟踪构造方法，可以发现initialCapacity参数最终会传递给这个方法，源码如下：

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

为了更好的理解转换过程，举几个例子：

  1. 构造参数为3，该方法就返回4；
  2. 构造参数为10，该方法就返回16；
  3. 构造参数为32，该方法就返回32，因为32本身就是2的幂次方

假设方法参数cap = (1<<30) + 1，那么n = 1<<30，有如下转换过程：

01000000 00000000 00000000 00000000 (n)
01100000 00000000 00000000 00000000 (n |= n >>> 1)
01111000 00000000 00000000 00000000 (n |= n >>> 2)
01111111 10000000 00000000 00000000 (n |= n >>> 4)
01111111 11111111 10000000 00000000 (n |= n >>> 8)
01111111 11111111 11111111 11111111 (n |= n >>> 16)

认真体会源码及示例，tableSizeFor方法告诉了我们三件事情：

第一，2的幂次方是怎么转换的

转换过程是通过>>>和|两个操作完成，全部执行完以后，第一个二进制1之后的位空间就都会变成1，最后return的时候再执行个n+1就能得到2的幂次方，巧妙！

第二，tableSizeFor的转换最大值

Java中的int是有符号类型，占用32bit空间，第一个bit是符号位，0表示正数，1表示负数。

当n = 1<<30的时候，n |= n >>> 16得到的结果就是int的最大值，再执行n+1操作，最大值就会溢出，变成最小值。

所以，n不能大于1<<30，进而推导可得cap最大值为1<<30，刚好是1G。

也就是说，通过tableSizeFor转换能得到的最大值是2的30次方，这就是1G，最大容量字段MAXIMUM_CAPACITY定义的由来：

static final int MAXIMUM_CAPACITY = 1 << 30;

第三，先减1再加1的作用

首先提出疑问：tableSizeFor方法第一行先做了个减法操作n = cap - 1，最后return的时候又做了个加法操作n + 1，为什么？多此一举？

并非多此一举，减1加1是为了保证方法参数cap刚好等于2的幂次方时，转换结果还是它本身，例如cap = 128时：

00000000 00000000 00000000 10000000 (cap = 128)
00000000 00000000 00000000 01111111 (n = cap - 1)
00000000 00000000 00000000 01111111 (n |= n >>> 1)
00000000 00000000 00000000 01111111 (n |= n >>> 2)
00000000 00000000 00000000 01111111 (n |= n >>> 4)
00000000 00000000 00000000 01111111 (n |= n >>> 8)
00000000 00000000 00000000 01111111 (n |= n >>> 16)
00000000 00000000 00000000 10000000 (return n + 1)

这就是二进制运算特性，巧妙！

最后的结果赋值给了属性变量threshold：

int threshold;
this.threshold = tableSizeFor(initialCapacity);

变量threshold是阈值的意思，表示的含义是HashMap中存储的元素超过这个数值的时候，底层数组table就要进行扩容了。

数组初始化之前，threshold不是阈值的意思，这点要理解！

通过构造函数初始化HashMap对象之后，底层数组table并没有被分配数组空间，此时的threshold保存着数组初始长度信息，还不是阈值的含义！

HashMap首次添加元素时，第一次为数组table分配空间，通过threshold得知第一次分配的数组的长度。之后，threshold会被重新计算，再往后才是阈值的含义。

threshold计算方法是：

int threshold = table.length * loadFactor

负载因子loadFactor默认是0.75：

static final float DEFAULT_LOAD_FACTOR = 0.75f;

负载因子loadFactor也可以在通过构造方法指定。

HashMap添加/更新

向HashMap添加(key, value)的键值对象，最常用的方法是：

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

顺着这个方法追下去，就是完整的添加/更新逻辑。

hash(key)

添加第一步，就key做了一个哈希处理：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

从中可以看到两个知识点：

  1. key == null：哈希值是0，所以，键值对象(null,value)永远存储在数组table的0号位置，也就是第一个位置
  2. key != null：在JVM默认哈希值的基础上，又做了一个变换，让哈希值二进制高16bit参与到低16bit运算中

为了更好地理解，举个具体的例子，假设key的哈希值是16711680：

00000000 11111111 00000000 00000000 (h = key.hashCode())
00000000 00000000 00000000 11111111 (h >>> 16)
00000000 11111111 00000000 11111111 (h ^ h >>> 16)

通过Java已有的方法hashCode()就可以计算出一个随机的哈希值，为什么非要再转换一次呢？为什么要将哈希值的高16bit数据融合到低16bit里面呢？

回答这个问题之前，先了解另一个知识点：hash值映射到数组table下标值的规则。

int h = key.hashCode();   // Object方法计算出的哈希值
int hash = h ^ h >>> 16;  // 哈希值高16bit融合进低16bit
int n = table.length;     // 数组table的长度
int i = (n - 1) & hash;   // hash值映射到数组下标
table[i] = value;         // 数组赋值Node<K,V>对象

这段代码是追踪源码后，得到的哈希值映射逻辑，映射规则是(n - 1) & hash。

这是个掩码映射思想，可类比网络IP设置中的掩码。

截止到目前，数组table的长度始终都是2的幂次方，n - 1得到的就是高位一串0，低位一串1的二进制数字，也是数组下标的最大值。

举个例子：

00000000 00000000 00000000 00010000 (n = table.length = 16)
00000000 00000000 00000000 00001111 (n - 1)
00000100 00100110 00100101 10001010 (hash)
00000000 00000000 00000000 00001010 (i = (n - 1) & hash)

计算出数组下标i = 10，由此可以看出，hash真正能决定数组下标位置的的只有几个低位二进制数值，高位二进制对映射规则没有影响。

实际使用HashMap的时候，存储元素的个数通常不会超过2的16次方，也就是65536个。

在这个实际应用场景的约束下，计算出来的hash最多只有低16bit有用，高16bit完全没用。如果两个hash低16bit相同，高16bit不同，它们就会被映射到同一个数组下标，存储在同一个位置。

把hash二进制的高16bit融合进低16bit，就会改变低16bit的数值，进而得到不同的数组下标，存储在不同的位置。

现在可以回答之前的问题了：HashMap之所以要再次计算hash，将高16bit数据融合进低16bit，是为了在实际应用中，得到更好的哈希散列性，降低哈希碰撞的概率。

putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)

这是HashMap添加/更新元素的核心方法，源码如下，排版有压缩：

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

从这段代码里，可以整理出添加/更新逻辑：

  1. 首次添加元素时，数组table进行第一次初始化
  2. 根据哈希映射规则(n - 1) & hash计算出数组下标i
  3. 如果table[i] == null，创建Node<K,V>对象，封装插入信息，插入数组table[i]
  4. 如果table[i] != null，说明table[i]可能是一个Node<K,V>链表，也可能是一个红黑树TreeNode
  5. 如果table[i]是一个Node<K,V>链表，就执行链表的新增/更新逻辑
  6. 如果table[i]是一颗TreeNode红黑树，就执行红黑树的新增/更新逻辑
  7. 如果链表新增元素后，链表长度超过8个，就立刻将链表转换成红黑树结构。这么说其实是不太对的，但是为了讲述方便先这么理解吧，后面讲红黑树结构的时候，会说明为什么不对
  8. 新增元素时，如果是链表结构，就添加链表尾部，如果是红黑树，就根据树的特性添加到合适位置。但是还要知道，HashMap使用红黑树的时候，依旧记录着链表信息，在这个链表信息里面，元素依然是在最后的
  9. 如果两个元素的hash和key相同，就说明是相同的元素，执行更新操作，更新元素value值
  10. 方法参数onlyIfAbsent == true时，表示HashMap只能新增元素，不能更新元素
  11. 如果是更新元素，方法返回值是更新前的元素value值，如果是新增操作，方法返回的是null
  12. 如果集合元素数量size超过threshold阈值，就进行扩容操作
  13. 每次新增/更新完成后，都会执行一个操作++modCount，这个字段记录的是集合写次数，跟迭代器的使用有密切联系，可以达到迭代器的fail-fast效果

treeifyBin(Node<K,V>[] tab, int hash)

这个就是链表结构转化成红黑树的方法，源码如下，排版略有压缩：

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        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);
    }
}

从中整理出转换逻辑：

  1. 如果数组table.length < 64，只进行扩容操作，不会进行红黑树转换。这是HashMap链表转换红黑树的另一个条件，数组长度需要满足阈值条件MIN_TREEIFY_CAPACITY = 64
  2. 红黑树转换过程，是先将Node<K,V>链表封装成TreeNode<K,V>链表，然后再通过treeify(Node<K,V>[] tab)方法真正将其转换成红黑树。所以转换后，这些元素组成的结构既是红黑树，又是链表，两者特性兼而有之！赞叹！巧妙！

resize()

当HashMap首次添加元素，或者，添加元素后HashMap元素数量超过threshold时，数组table就会进行扩容操作。

扩容过程包含两件事情：

  1. 扩大底层数组table容量，也就是扩大HashMap的哈希槽，可以容纳更多的key
  2. 哈希槽增加后，集合元素需根据hash值重新映射数组table下标位置，这个过程叫做重哈希

这两件事情都是在resize()方法中完成，第一件事情，扩大数组容量的相关源码如下：

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    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;
        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;
    // 以下是重哈希部分，省略
}

阅读这段代码，可以理出数组扩容的逻辑：

  1. table第一次初始化时，threshold表示数组长度信息，如果没有指定，就使用默认值DEFAULT_INITIAL_CAPACITY = 16
  2. 默认负载因子是DEFAULT_LOAD_FACTOR = 0.75f，表示当集合元素数量达到table.length * 0.75的时候，就触发扩容机制
  3. 扩容时，数组长度以2倍的速度递增，创建2倍长度新数组，取代原数组
  4. 数组长度最大值是Integer.MAX_VALUE，它跟MAXIMUM_CAPACITY的关系是Integer.MAX_VALUE = MAXIMUM_CAPACITY * 2 - 1
  5. 当数组长度达到Integer.MAX_VALUE时，threshold阈值也会设置成Integer.MAX_VALUE

理清了扩容的逻辑，再来看看重哈希的逻辑，相关源码：

final Node<K,V>[] resize() {
    // 以上是数组扩容逻辑，省略
    Node<K,V>[] oldTab = table;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null) newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null, hiHead = null, hiTail = null, next;
                    do {
                        next = e.next;
                        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);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

源码有点长，排版上做点压缩。分析这段代码，理出重哈希逻辑：

  1. 基本思路，遍历原数组，根据hash计算元素在新数组中的存储位置，存入新数组
  2. 原数组table[j]，可能是null，可能是一个Node<K,V>对象，也可能是多个Node<K,V>对象组成的链表，还可能是个TreeNode<K,V>红黑树
  3. 如果table[j] == null，说明这个位置没有存储对象，也就不需要处理
  4. 如果table[j]只是一个Node<K,V>对象，直接计算新的下标值e.hash & (newCap - 1)，存入新数组即可
  5. 如果table[j]是一个Node<K,V>链表，就根据规则e.hash & oldCap将其拆分成两个链表，分别存储在新数组newTab[j]和newTab[j + oldCap]的位置。这与直接计算元素下标e.hash & (newCap - 1)效果是一样的，且更为简单直接
  6. 如果table[j]是一个TreeNode<K,V>红黑树，拆分就稍微复杂一点，需要详细分析TreeNode<K,V>的split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit)方法，这里先搁置，另起一节细说

对于第5点和第6点，有必要单独拿出来再细说一下。

关于第5点

举个例子，理解table[j]是个Node<K,V>链表的情况：

假设当前HashMap为8，现有两个Node<K,V>对象node1和node2，它们的信息如下：

n = table.length = 8

node1.hash == 0001
(n - 1) & hash = 0111 & 0001 = 0001 = 1
node2.hash == 1001
(n - 1) & hash = 0111 & 1001 = 0001 = 1

table[1] = node1, node2

所以，node1和node2分别都存储在数组table[1]的位置，形成链表。

现在要进行扩容，重哈希，node1和node2在新数组中的情况：

oldCap = 8
n = table.length = 16

node1.hash == 0001
(n - 1) & hash = 01111 & 0001 = 0001 = 1
table[1] = node1 // 链表拆分规则：hash & oldCap = 0001 & 1000 = 0000

node2.hash == 1001
(n - 1) & hash = 01111 & 1001 = 1001 = 9
table[9] = node2 // 链表拆分规则：hash & oldCap = 1001 & 1000 = 1000

可以发现，其实有两种规则方法，可以完成扩容时的重哈希操作：

  1. 哈希映射规则：(n - 1) & hash
  2. 链表拆分规则：hash & oldCap

关于第6点

拆分红黑树后需要考虑的问题是拆分后的两个结构应该如何存储？是使用TreeNode<K,V>红黑树结构？还是使用Node<K,V>链表结构？

相关源码如下：

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    // Relink into lo and hi lists, preserving order
    TreeNode<K,V> loHead = null, loTail = null;
    TreeNode<K,V> hiHead = null, hiTail = null;
    int lc = 0, hc = 0;
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        next = (TreeNode<K,V>)e.next;
        e.next = null;
        if ((e.hash & bit) == 0) {
            if ((e.prev = loTail) == null) loHead = e;
            else loTail.next = e;
            loTail = e;
            ++lc;
        }
        else {
            if ((e.prev = hiTail) == null) hiHead = e;
            else hiTail.next = e;
            hiTail = e;
            ++hc;
        }
    }
    if (loHead != null) {
        if (lc <= UNTREEIFY_THRESHOLD) tab[index] = loHead.untreeify(map);
        else {
            tab[index] = loHead;
            if (hiHead != null) loHead.treeify(tab); // (else is already treeified)
        }
    }
    if (hiHead != null) {
        if (hc <= UNTREEIFY_THRESHOLD) tab[index + bit] = hiHead.untreeify(map);
        else {
            tab[index + bit] = hiHead;
            if (loHead != null) hiHead.treeify(tab);
        }
    }
}

整理出拆分逻辑：

  1. 因为TreeNode<K,V>本身也保存有链表信息，所以先根据上面第5点讲的链表拆分规则hash & oldCap将其拆分成两个子链表
  2. 如果子链表长度不大于UNTREEIFY_THRESHOLD = 6这个阈值，就转换成Node<K,V>链表，存入新数组对应位置
  3. 如果子链表长度大于UNTREEIFY_THRESHOLD = 6这个阈值，就转换成TreeNode<K,V>红黑树，存入新数组对应位置

关于链表和红黑树互转的小总结：

  1. 链表转红黑树的时候，需要元素数量大于等于9
  2. 红黑树转链表的时候，需要元素数量小于等于6

HashMap删除

删除逻辑相对简单，核心源码是：

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

逻辑整理如下：

  1. 根据hash规则映射数组table下标i，如果table[i] == null，证明元素不存在，无需删除，直接返回null
  2. 如果table[i] != null，那么table[i]可能是链表，也可能是红黑树，所以要区分节点类型，从链表中查找，或者从红黑树中查找
  3. 如果找到元素，就从相应结构中删除，并返回删除元素
  4. 方法参数matchValue == true，表示删除的时候，不仅要key相等，而且value也要相等，才能删除。当然，这个特性很少用到
  5. 方法参数matchValue == false，表示从红黑树结构中删除元素后，不重新移动树的其它节点。这个也不常用，仅作了解

HashMap查找

查找逻辑也简单，核心源码：

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 && ((k = first.key) == key || (key != null && key.equals(k))))  // always check first node
            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;
}

逻辑整理如下：

  1. 根据hash映射数组table下标位置i
  2. 如果table[i] == null，说明没有该元素，返回null
  3. 如果table[i] != null，说明table[i]可能是链表，可能是红黑树
  4. 如果table[i]是链表，就以链表方式找，有就返回节点，没有就返回null
  5. 如果table[i]是红黑树，就以红黑树方式找，有就返回节点，没有就返回null
  6. 如果存在节点，上层的封装方法get(Object key)也就是从节点中再返回节点的value值就行了

线程安全

并发场景下，HashMap是非线程安全的。

如果要线程安全，就用ConcurrentHashMap类。

数组table扩容、集合数据重哈希，这两个过程是最容易出现线程问题的。

因为随着集合数据量的增加，重哈希是一个比较耗时的操作，扩容过程其实就是原有集合数据重新写入新数组的过程。

多线程场景下，短时间内向同一个地方大量写入数据，就是容易出现线程安全问题。

如果出现线程安全问题，HashMap最可能出现的现象就是数据丢失，具体过程就不分析了。

写的够多了，就到这里吧，Markdown编辑器已经顶不住了，太卡了。

仲夏北斗星
关注
专栏目录
【JAVA基础】JDK8 HashMap 源码深度解析
秀强的专栏
08-27 412
而且当 key 是 Integer 时且小于等于 65535 时，(h = key.hashCode())^ (h >>> 16) 和 key 的值是相等的，所以此时 key 是有序递增的。当 key 大于 65535 以后，高 16 位就不全是 0 了，(h = key.hashCode())^ (h >>> 16) 的值就与 key 不相等了。n = 16 时，(h ^ (h >>> 16)) & (n-1) = 5， 即计算出来的下标是 5。JDK8：数组 + 链表 + 红黑树。...
JDK1.8 Hashmap源码解析
A_BCDEF_的博客
05-14 548
hashmap这样做是为了之后运算（位运算）方便，同时在hash时选择更好的hash函数，以抵消2的n次方带来的不便。index = (n - 1) & hash，如果这一位是0，则index = index，否则，index = index + oldCap。线程2唤醒开始执行扩容，此时线程2指向node1，且next节点为node2，但node2的next节点又为node1，出现死循环。扩容，就是给原来的容量乘2，也就是把原来容量oldCap左移一位，这时2^n的好处就表现出来了。
JDK8 HashMap源码解析
freak_csh的博客
07-16 398
JDK8 HashMap源码解析
JDK8-HashMap源码解析
LOST JACK
06-17 316
HashMap（JDK8） HashMap = 数组 + 链表 + 红黑树 一、HashMap初始化 HashMap默认容量大小为16，最大容量为1073741824（2^29）。 当链表长度大于等于8时并且Hash桶数量大于等于64时，链表转为红黑树。 当红黑树节点数量小于等于6时，红黑树转为链表。 /** * The default initial capacity - MUST be a power of two. */ static final...
【JavaSE】HashMap源码分析(jdk8)
weixin_46153050的博客
02-18 486
概述 HashMap本质是一个hash表，采用拉链法解决冲突，并且在某个位置的链表过长时将其转化为一棵二叉搜索树降低插入的开销； 按照以下顺序去阅读HashMap的源码是不错的选择 构造函数 put( )方法 remove( )方法 get( )方法 一、主要成员 1.1 成员属性 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Seriali
JDK8中的HashMap源码解析与理解
TankyZhang的博客
10-30 900
jdk8中的HashMap源码解析与理解 一、预备知识 关于hash： ​ 有个非常关键的特点，不定长度的输入固定长度的输出，将一个对象经过一定的hash算法映射成相同长度的hash值。 hash冲突的避免： ​ hash是无法完全避免的，只能通过各种方法手段尽量的减少hash冲突。 关于hash碰撞的解决方案： 开放地址法：假设一个数组有四个长度此时存放了[8,null,10,11,null]两个为null的位置代表没有数据，此时如果有个15来了，15mod 4=3那么这个15应该放在下标为3的位置上
基于JDK8的HashMap源码解析
Keep Learning
07-19 9500
常见概念解释 常量解释 hash 值的计算 put 操作 resize 扩容操作
JDK1.8 HashMap源码解析
sinat_32945925的博客
10-15 192
HashMap源码解析 1.hashmap的默认容量为16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 2.hashmap的最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; 3.hashmap的加载因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; 当hashmap的容量增加到当前容量的3/4时，会触发扩容
HashMap 源码详细分析(JDK1.8)
windy杨树的博客
03-16 429
目录 1. 概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 -HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。另外，需要注意的是，HashMap 是...
JDK8 HashMap源码
dreambyday
03-13 617
1 HashMap 1.1 常量 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 一个随机值，用于序列化 private static final long serialVersionUID = 362498820763181265L; /** * 无参初始化时HashMap的
JDK8-HashMap源码浅析
weixin_45149504的博客
06-21 119
总叙 HashMap是Map接口下一个实现，提供键值对的存储。JDK1.7及以前通过数组+链表实现数据的存储，而JDK8开始加入了红黑树，存储结构做了优化，即存在两种存储方式：数组+链表或数组+红黑树。 如何实现存储 在开始之前可以先看看Hash表的相关内容。 Hash表：理解为一个包含了多个格子的表，每个格子存放不同hash值的元素。例如格子1存放hash值为50的对象、格子2存放hash值为100的对象… Hash碰撞：不同的值计算出的Hash值一般情况下应该是不一样的，因而会存放到Hash表中的不
Java基础之jdk8 HashMap源码解读
we.think
09-17 418
目录一、存储特点1.1 数据结构的演变1.2 特点二、类结构2.1 继承关系2.2 成员变量2.3 构造方法2.3.1 HashMap(int initialCapacity, float loadFactor)2.3.2 HashMap(Map<? extends K, ? extends V> m)2.4 成员方法2.4.1 添加节点元素2.4.2 内部添加节点元素2.4.3 将链表转换为红黑树2.4.4 扩容2.4.5 删除2.4.6 查找元素三、思考题3.1 jdk8为何需要引入红黑树？
JDK8的HashMap源码解析
如风的博客
05-31 317
hashMap底层数据结构 - JDK1.8 之前 底层 数组+链表，大量的元素都存放到同一个桶中时，这个桶下有一条长长的链表，极端情况HashMap 就相当于一个单链表，假如单链表有 n 个元素，遍历的时间复杂度就是 O(n) - JDK1.8 底层 数组+链表+红黑树 ，hash冲突后处理办法由原来的链表结构，引入了 红黑树 概念 - 重要对象 java.util.HashMap.Node 链表Node节点 java.util.HashMap.TreeNode TreeNode 红黑树 - 重要成员变量
Java8 HashMap源码解析
CodingSoldier的博客
11-03 557
HashMap底层数据结构 HashMap底层数据结构是 数组 + 链表，当链表长度大于等于8，链表将转为红黑树。 HashMap的一些重要成员变量 // 初始容量大小，1左移4位是10000，转为十进制是16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 /** * 同时满足 HashMap元素超过64个，且链表长度超过8 才将链表转为红黑树 */ // 树化阀值 static final int.
HashMap源码分析
和大黄的博客
02-24 8554
1、hashmap的数据结构 要知道hashmap是什么，首先要搞清楚它的数据结构，在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，hashmap也不例外。Hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列“），请看下图（横排表示数组，纵排表示数组元素【实际上是一个链表】）。 上图中，X轴方向为HashMap的数组容器，Y轴方向，为每个相应位置的单向链表。每一个元素都是一个包含如图所示四个属性，k
HashMap JDK8源码解析
qq_50596778的博客
11-05 304
HashMap -1.8 源码解析 简介： HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一，是非线程安全的。 HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个 JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。 JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，
Java集合框架之三：HashMap源码解析
weixin_30915275的博客
02-24 88
版权声明：本文为博主原创文章，转载请注明出处，欢迎交流学习！ HashMap在我们的工作中应用的非常广泛，在工作面试中也经常会被问到，对于这样一个重要的集合模型我们有必要弄清楚它的使用方法和它底层的实现原理。HashMap是通过key-value键值对的方式来存储数据的，通过put、get方法实现键值对的快速存取，这是HashMap最基本的用法。HashMap底层是通过数组和链...
JDK8HashMap源码
Jak的博客
04-11 290
一、红黑树 1.1 红黑树的定义 红黑树是一种自平衡的二叉查找树，它的节点的颜色为红色和黑色。它不严格控制左、右子树高度或节点数之差小于等于1。通过左旋、右旋、变色保证平衡 1.每个节点非红即黑； 2.根节点总是黑色的； 3.每个叶子节点都是黑色； 4.红节点的子节点一定是黑色的。 5.从任一节点到叶子节点必须包含相同数量的黑色节点。 AVL树是高度平衡的而红黑树不是高度平衡的，它只要求部分地达到平衡要求，结合变色，降低了对旋转的要求从而提高了性能。在最坏的情况下也可以保证O(logN)
集合源码分析之三：HashMap源码解析（JDK8）
weixb_2012的博客
12-28 289
参考博客原址：https://blog.csdn.net/zxt0601/article/details/77413921 1 概述 概括的说，HashMap 是一个关联数组、哈希表，它是线程不安全的，允许key为null,value为null。遍历时无序。  其底层数据结构是数组称之为哈希桶，每个桶里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。  在JDK8中，当链表长度达到8，...
HashMap演进与JDK11源码解析
当链表长度超过一定阈值（通常是8）时，HashMap会将链表转换为红黑树；当树的节点数量减少到一定程度（通常是6）时，又会将红黑树转换回链表。这种优化减少了遍历长链表的时间，提高了整体性能。 HashMap中的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值