最全的HashMap源码解析！

杨利霞

最全的HashMap源码解析！
+ r+ D' V. }' b/ cHashMap源码解析

HashMap采用键值对形式的存储结构，每个key对应唯一的value，查询和修改的速度很快，能到到O(1)的平均复杂度。他是非线程安全的，且不能保证元素的存储顺序。

他的关系结构图

4 Z" H; o' b; H* t% [
HashMap继承了AbstractMap，而AbstractMap的父类又是Map接口，所以HashMap也间接实现了Map接口，并且实现了Serializable接口，能被序列化，还实现了Cloneable接口可被克隆（浅拷贝）。
0 F, V# M2 I6 O9 m- D. {7 V% A" O
在Java8中HashMap采用了数组+链表+红黑树的数据结构。数组的每个元素又被称作桶，Node<key,value>。在添加元素的时候，会根据hash算法计算出不同的key对应的数组下标，注意这里我可没说计算出来的下标都是不同的，因为hash算法也有优略之分，不同的key可能对应同一个数组下标，这种现象被称为哈希冲突。为了解决哈希冲突带来带来的问题，所以在jdk1.8之前，当根据key计算出的数组下标上，已经有了元素，这个位置已经被占用了，这时候就把该元素放在此数组下标的链表的尾部。

+ t  G9 D' V' v4 K. f: T( e但是一个链表的长度达到一定级别时，查询有时需要遍历整个链表，时间复杂度是O(n)。所以在jdk1.8后，当链表的长度大于等于8并且整个数组的大小大于等于64时，将这个链表转化成红黑树，红黑树的查询效率是O(logn)相比链表有提高了查询速率。

红黑树的特点
* O5 }1 f( F% ?# @
节点是红色或是黑色
2 X. _( A" [! s9 h8 \. p: Q根节点是黑色
叶子结点是黑色（空节点）
从任意节点到每个叶子结点的路径上包含相同个数的黑色节点
每个红色节点的两个子节点都是黑色。也就是说从叶子结点到根节点的路径上不能出现两个连续的红节点。
存储结构
) I# E/ [" r' p$ J" h6 x3 w, q! s
2 b- P- j/ I" d3 d  v3 w- P/ `源码分析重要属性
) a4 Z6 e" a, a, B8 \/ E//默认初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
: B; O- R8 Q4 X) }( W2 W
& H1 a( k! Q# C, Y4 [* E& L  //最大容量是2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;
( f/ S+ {% ?1 B- E% l7 f8 z
2 ^8 V$ P2 [& J- Z  k$ d, `    //当构造方法中没有指定负载因子时用这个默认的
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
0 s+ w+ V2 F- T* c7 \5 _  d% _3 z
  e" H! E) R% d6 k# `/ a6 B   //当链表中桶的个数大于等于8就会变成红黑树
( x7 }5 L2 ]! P/ J    static final int TREEIFY_THRESHOLD = 8;
+ S7 W' J' L! s! h' E; ^
/ S; z$ [& l. g   //当红黑树大小小于等于6时红黑树会转化成链表
% l# T( [1 n  g8 G, ]$ J    static final int UNTREEIFY_THRESHOLD = 6;
& k7 ~* T: f# A5 c  x. \
) v" _- f7 Q0 f3 C, m   //当数组容量大于64时链表才能转成红黑树
( S+ G$ O: K1 q4 f    static final int MIN_TREEIFY_CAPACITY = 64;

4 ?8 Z* {9 l: ?2 O$ D* r' o: K    //数组，数组的大小是2的n次幂
    transient Node<K,V>[] table;
- ~, o6 d2 y. C) @" M2 \    //存放具体集合
    transient Set<Map.Entry<K,V>> entrySet;
" t2 {, O9 l* Q" R0 y& w6 ]! P0 W
6 {% U& O1 q0 G   //存放元素的个数
    transient int size;
6 v! V7 }6 T3 V. B
/ ?' n' W" I! |/ u& A0 v    //每次更改结构的计数器
: \+ f6 A( c1 J) O5 H2 a' `    transient int modCount;
% ~) ^' L* h% ?
# e0 d# Y; E1 k. F- E% C    //当HashMap所能容纳键值对数量的最大值，超过这个值，需要扩容
    int threshold;
" a) t9 C! ^/ }) K0 P: d
   //负载因子
    final float loadFactor;
loadFactory加载因子
loadFactory加载因子是通知数组存放数据的疏密程度，他的值越接近于1，存放在数组到的数据也就越密集，也就是说这个值越大，链表的长度会增加的越快。当他的值趋近于0，存放在entry中的数据就会越少，也就越稀疏。

threshold
给定的默认容量大小是16，负载因子时0.75，Map在使用过程中不断的往里面存放数据，当存放的桶的个数达到了12=16*0.75，就会扩容，扩容的时候比较消耗性能。

8 B" X1 m8 N( b2 I& |& A$ q你也许有疑问，12是怎算出来的，其实这个就是threshold属性，threshold=capacity*loadFactoy，当Size大于等于threshold这个值，就需要对数组进行扩容操作了。

从上面的源码我们可以知道，容量最大是2的30次方，当数组大小 大于等于64并且链表长度大于等于8时，链表就会转化成红黑树。当红黑树的桶的个数 小于等于6时就会变回链表。
* j  E5 S0 ]5 U- n* F4 d
链表Node节点

* S' ~- `2 M) R$ Z//Node 节点实现了Map.Entry<K,V>
5 t: N$ c% }6 B7 U0 Hstatic class Node<K,V> implements Map.Entry<K,V> {
        final int hash; //hashCod
        final K key;//键
* l4 O* J& }, `. b/ ?1 R        V value;//值
# H! s' q" `6 c9 S( I8 N% E" z" `+ j        Node<K,V> next;//指向下一个节点
& G6 Y2 B! N0 E, Q: ]8 N& L% h1 K, r        //构造函数
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
# |5 L; y. R: |4 G% Q/ V            this.key = key;
            this.value = value;
            this.next = next;
        }
0 K6 A* I& ?. H! w# V
$ Z3 n: p: T  Q: R& N0 [        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        //重写toString方法
3 v* d' P# ?9 [! E; n% R        public final String toString() { return key + "=" + value; }
        //重写hashCode方法
        public final int hashCode() {
* K  e. e7 M7 S            return Objects.hashCode(key) ^ Objects.hashCode(value);
) I  Q  v% j  a8 z. z- G        }
  z1 n1 D) P/ ^1 b
! H$ r4 h6 [4 {/ S5 `( w        public final V setValue(V newValue) {
+ W4 o, t7 V+ C+ K' ^& G            V oldValue = value;
# g# K" V- C9 |' P: u! M8 W            value = newValue;
9 X/ E% L, L. S8 V            return oldValue;
        }
        //重写equals方法
" S/ Y, q+ V* J+ v- P2 {        public final boolean equals(Object o) {
- f# O" \. Q: f$ h; g; o& }            //如果内存地址一致直接返回true
) F, s6 z/ E9 J- h            if (o == this)
- v6 x* r1 V9 ]( H. Z                return true;
                //比较的节点必须实现这个Map.Entry
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
; c8 o- v1 D/ A! P                    Objects.equals(value, e.getValue()))
                    //键和值都相等才能返回true
                    return true;
            }
            return false;
        }
    }


& v+ m5 u" e! ?' ^( @! `+ \3 Q红黑树节点结构
//TreeNode继承了LinkedHashMap中的Entry节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 红黑树的父亲节点
* X/ F8 O: g( a4 s' P' c6 @        TreeNode<K,V> left; //左子树
) }0 k# O! Y- P3 S0 f' v+ E6 J        TreeNode<K,V> right;//右子树
        TreeNode<K,V> prev;    // 链表中的节点，在删除元素的时候可以快速找到他的前驱节点
        boolean red; //是否变色，
        //构造方法
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
& G1 H8 ?1 f! f# O* V/ L# @) a        }
2 C0 ?# v/ M2 @
( K# Q  V% ^' e) Y        /**
0 R' W$ u% m' v2 C" J         * 返回根节点
1 N( q: ~, ~( `" I* F% G         */
4 v! P+ u- d! x  K  p: @7 e        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
) t0 t' f' O% V6 N; G                if ((p = r.parent) == null)
1 q7 N+ W' Z3 r) f/ y5 ?6 h                    return r;
9 P3 w) b- S/ J8 m2 R                r = p;
            }
        }
& Y; g2 H- _/ s
  ^3 n5 o. ^  |9 c# w- T构造方法/**
! X& k# D$ ]9 P" ^5 [- O+ N7 o* 构造一个空的HashMap并指定初始容量和负载因子。
( r) u& o" }# f1 N! n*
) N+ ?* }: M1 s# L  f**/
# m) [" C1 }- ]; Spublic HashMap(int initialCapacity, float loadFactor) {
        //如果初始容量小于0，抛出非法参数异常
        if (initialCapacity < 0)
3 J* r  G; ~- f% L, [            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
1 W3 |6 Y1 T- a4 X! B         //如果初始容量大于最大的容量也就是2^30,那么就按照最大的初始容量赋值。
& S! \" ], N2 {6 J& ^        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
         //如果负载因子小于0或者是NaN（float NaN = 0.0f / 0.0f;）也会抛出非法参数异常
( `% C/ K( ~2 L) d0 }9 g6 b        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
/ k( C) B, }6 _& g5 e        this.loadFactor = loadFactor;
2 T* ?2 {6 m( x) o! J1 ?! L$ F4 f        this.threshold = tableSizeFor(initialCapacity);
+ S, m+ ?! u5 m, G& I- B* \4 A    }
0 F# o" i; n9 z$ B$ c, r//如果只是指定了初始容量那么负载因子就是默认的0.75
public HashMap(int initialCapacity) {
7 C& }% R4 W6 C2 L2 s' h% a' P        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

& k/ J$ s- o9 A  m$ o    /**
     * 如果什么都没指定，也就是无参构造，则初始容量是16和负载因子是0.75
     */
: }" {1 K: d5 N; z4 _; W    public HashMap() {
- t: R* t* r% w; K0 I        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

: m6 j% Y3 i- x3 T- P    /**
1 K) t- o  h- h7 S     * 包含另一个Map的映射，如果被映射的Map是一个null会抛出空指针异常
     * 负载因子时默认的
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
0 d2 J# D  P& m) ^6 V, E        putMapEntries(m, false);
    }
* f# b( ^- z( F: q
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
$ _) ~2 ^" S  O        int s = m.size();//s是map的大小
        if (s > 0) {
            if (table == null) { // pre-size
- H8 o2 V# {$ G0 Z. j; V2 v                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
0 z; |' |& V1 j, V. V" ?                if (t > threshold)//如果t大于扩容的阀值就初始化阀值
5 R, P. D7 ]4 l7 J1 y7 Z                    threshold = tableSizeFor(t);
- [3 c  a* @8 g4 T# x% _4 P" E- t            }
) d9 x5 C3 n3 R; u: }0 F) N3 e            //如果这个map中的元素个数大于扩容的阀值就得扩容
            else if (s > threshold)
                resize();
                //将map中的key和value都添加到HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
1 L. k2 J2 F2 M( L: V  s" @1 o0 y. d                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
3 V3 m1 D, Y$ {1 j; K* n: h; x            }
9 d& ^* g3 f/ }! {) n        }
    }


' U5 x* Z: R! O8 t/ i* k/**
* 构造一个空的HashMap并指定初始容量和负载因子。
*
/ q' D/ X$ ~5 E; P! K* a6 }**/
. S% |. g+ S, \3 b2 ?public HashMap(int initialCapacity, float loadFactor) {
* X; d2 ], W( v4 v# M& k6 |. u        //如果初始容量小于0，抛出非法参数异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
: ?+ b$ l5 U$ _5 W) F% S6 k! V                                               initialCapacity);
         //如果初始容量大于最大的容量也就是2^30,那么就按照最大的初始容量赋值。
        if (initialCapacity > MAXIMUM_CAPACITY)
. s& b/ d3 `6 |4 I/ D: T            initialCapacity = MAXIMUM_CAPACITY;
         //如果负载因子小于0或者是NaN（float NaN = 0.0f / 0.0f;）也会抛出非法参数异常
  D# R) ?7 v5 _2 R' u" Y        if (loadFactor <= 0 || Float.isNaN(loadFactor))
6 d0 o/ x- y5 e9 }            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
//如果只是指定了初始容量那么负载因子就是默认的0.75
# o- d- ^' N( A. M9 r$ cpublic HashMap(int initialCapacity) {
& w$ G$ h3 B0 e* H        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
0 a8 }, v8 A; r& _: o1 {
    /**
     * 如果什么都没指定，也就是无参构造，则初始容量是16和负载因子是0.75
  D. W* c# @0 F' Y     */
+ g( Y# m+ ?; {( u. S) c# o7 b. K4 V, j    public HashMap() {
9 W6 J/ O6 V" t! k- c        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    /**
     * 包含另一个Map的映射，如果被映射的Map是一个null会抛出空指针异常
     * 负载因子时默认的
$ b# c9 q" [1 N# g6 ?! S; |8 W     */
4 X2 ?+ q5 w# O, b    public HashMap(Map<? extends K, ? extends V> m) {
4 A$ U" U  z& Z% o        this.loadFactor = DEFAULT_LOAD_FACTOR;
, `0 m6 F$ j. `9 x1 l        putMapEntries(m, false);
8 ]) B1 F7 x: _, e8 n, S  s9 b    }

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
; R* @1 ?* y! S5 N  J        int s = m.size();//s是map的大小
7 Z- N  M$ r3 q6 u  V        if (s > 0) {
            if (table == null) { // pre-size
/ G& P# C* A) N* N                float ft = ((float)s / loadFactor) + 1.0F;
* f& G! Y5 x6 h. |  l                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)//如果t大于扩容的阀值就初始化阀值
: x* s0 u' v) Q+ C  ?8 |                    threshold = tableSizeFor(t);
            }
            //如果这个map中的元素个数大于扩容的阀值就得扩容
9 L' a1 f; L3 g# J0 d            else if (s > threshold)
  o8 A# x. q: c3 \; h$ }' _                resize();
                //将map中的key和value都添加到HashMap中
6 x& X! M5 \7 y9 e            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);
9 q+ [/ m& F1 u( W& @+ B) r            }
        }
3 z; z" c5 H9 r- N    }
! B% Q& K' ~  S9 X  W
put方法

向HashMap中添加元素

6 S2 ?# X- k4 B6 w    public V put(K key, V value) {
2 H- _+ Y0 F, G6 o9 U3 y8 R: t        return putVal(hash(key), key, value, false, true);
    }

    //扰动函数（哈希函数）
# Z- u$ I  n; w    static final int hash(Object key) {
# P- _! m& V/ P; ~% }+ R        int h;
3 {& P! z: r% H9 U" l        //如果key是null，那么映射出来下标是0，否则将key的hashCode和h无符号右移16位做疑惑操作，使计算出的hash更加分散。
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
. T8 N% f) n9 d4 E2 }# i' t    }

6 Z4 h" i: `4 V/ f8 n+ |, P# B//onlyifAbsent默认是false，表示即使key存在也可以覆盖旧值。
' ?( c2 D! ~# G  k2 M0 I" ?    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
6 J7 q9 C8 O& A( ^3 f5 E                   boolean evict) {
$ N" x3 v5 Z- L) q  c9 X                   //n表示数组的长度，i表示数组的下标，p表示下标 i对应的Node
3 G- H# ~! ^* ], X! C' C9 c        Node<K,V>[] tab; Node<K,V> p; int n, i;
7 D% N. s# J0 ]$ s        if ((tab = table) == null || (n = tab.length) == 0）//如果数组为空需要进行扩容
            n = (tab = resize()).length;
# X: J* Z3 V( [        if ((p = tab[i = (n - 1) & hash]) == null)//如果当前位置上没有节点那就新生成一个节点放上去
            tab = newNode(hash, key, value, null);
        else {//否则就代表这个位置已经有节点占用了，
1 d) ^6 f( j) z) l4 u8 w8 t9 \            Node<K,V> e; K k;//e表示临时节点
            if (p.hash == hash &&  
5 {1 U1 v+ Y/ g: O2 y; V. `' E; z                ((k = p.key) == key || (key != null && key.equals(k))))
                 // 如果key的hash和key本身的值都相等，直接把当前新增家电赋值给临时变量 e
                e = p;
, o1 a$ ]. B. C, E" \* t: X0 G2 x                //这里开始判断使用哪种类型的数据结构开始添加节点，如果是红黑树，就用红黑树的新增方式
$ k5 w0 a6 w$ `7 n. M0 t            else if (p instanceof TreeNode)
: ^) Q9 b, M4 n                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
% R3 m* \4 q  a% J4 s7 e! n* }            //否则采用链表的方式新增节点，遍历到链表的末尾，追加到后面
                for (int binCount = 0; ; ++binCount) {
                   //p.next==null表示到链表尾部
2 m+ ^$ v2 ^5 u( h                   if ((e = p.next) == null) {
4 X( X0 ?  G$ e" s                   //把新建的节点放在链表的最后
                        p.next = newNode(hash, key, value, null);
5 n: z1 f* O' l                        //节点个数大于等于树化的阀值就需要转换成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;//跳出循环
                    }
                    //循环遍历中发现 有元素和新增节点相等就结束循环
                    if (e.hash == hash &&
: P+ C8 e( U! `  ]                        ((k = e.key) == key || (key != null && key.equals(k))))
, c; q6 X# y* u- b1 k0 L1 r                        break;//相等就跳出循环
                    p = e;
                }
/ |; Q+ C# ?" N. z/ S" }# \+ J            }
4 U4 X) m5 U) s/ P! O$ j            //说明新节点的新增位置已经找到了
* J5 d8 i6 O/ `( x            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                //当onlyIfAbsent=false时才会覆盖
, m( h; o# Y5 i! Y+ O5 F# A                if (!onlyIfAbsent || oldValue == null)
# c) z2 k- r6 `* X; w8 R                    e.value = value;
" `' G6 w2 K& s; `                afterNodeAccess(e);
                //返回旧的值
                return oldValue;
& S$ q; e+ p' y: Q            }
        }
" e$ o2 ?! v2 L0 g        //结构修改计数器加一
% |8 r! H8 A. l8 c0 ?! |6 W5 I% }& a        ++modCount;
3 [; B9 g9 S0 X) m" h: _        //如果实际大小 大于扩容的阀值就会再次扩容
        if (++size > threshold)
# \7 V0 u: V5 a            resize();
            //插入后回调，具体实现交给了LinkedHashMap
        afterNodeInsertion(evict);
        return null;
    }
红黑树新增节点的过程

final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v) {
# V% q( P) s, m8 T& x/ F            Class<?> kc = null;
            boolean searched = false;
" v* \& \* @( I, p2 W. M8 W            //找到根节点
            TreeNode<K,V> root = (parent != null) ? root() : this;
            for (TreeNode<K,V> p = root;;) {
/ w1 O7 z; W. _% I3 X/ H                int dir, ph; K pk;
* S3 _8 I" \9 c6 y                //如果p的hash大于 h,那p就在h的右边
5 p- n: k2 @, n- t* B& K                if ((ph = p.hash) > h)
                    dir = -1;
                //如果p的hash小于 h,那p就在h的左边
                else if (ph < h)
$ r1 Y+ F% {$ p& t! E                    dir = 1;
                //如果将要新增的key已经在树中存在了那就直接返回p,这里代表插入的key没有实现Comparable接口，那就通过equals方法和值 比较是不是同一个key
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
; a% ^2 |- P6 {' v& @! \                    return p;
                    //如果key实现了Comparable的话，不再用hashcode比较，需要用compareTo方法
                else if ((kc == null &&
                //如果key没有实现Comparable接口，那么 comparableClassFor(k)返回的就是null
                          (kc = comparableClassFor(k)) == null) ||
                          //当前节点的键和入参的键不相等
                         (dir = compareComparables(kc, k, pk)) == 0) {
: F6 M$ a  o8 j                    if (!searched) {
" u/ U# a2 d6 N# I0 Q                        TreeNode<K,V> q, ch;
                        searched = true;
2 c' B+ i% B# ~                        if (((ch = p.left) != null &&
                             (q = ch.find(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.find(h, k, kc)) != null))
                            return q;
                    }
* X% T4 F2 o$ |# g7 j8 Q; X) `                    dir = tieBreakOrder(k, pk);
                }
# i7 v3 I/ j# `; ^8 i& R# q+ h
                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    Node<K,V> xpn = xp.next;
                    //生成新节点
# |2 D% b6 X; }( a  [                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
                    if (dir <= 0)
" J$ d% {8 E$ g* }- e( ~                    //如果dir=-1 新节点放在左子树
7 R& J: g1 ~0 ~                        xp.left = x;
                    else
                    //如果dir=1 新节点放在右子树
                        xp.right = x;
                    //当前节点和新节点建立父子关系后前后关系
  F( N) {  A4 W! S8 {. f- `- |' h# d5 w                    xp.next = x;
                    x.parent = x.prev = xp;
                    if (xpn != null)
                        ((TreeNode<K,V>)xpn).prev = x;
# X; O8 w! R# H# c: W; M                    moveRootToFront(tab, balanceInsertion(root, x));
7 Q( f( S' z$ n6 B* b             //balanceInsertion 对红黑树进行着色或旋转，以达到更多的查找效率，着色或旋转的几种场景如下
. ?, z- ]/ j8 u' O: r            //着色：新节点总是为红色；如果新节点的父亲是黑色，则不需要重新着色；如果父亲是红色，那么必须                 通过重新着色或者旋转的方法，再次达到红黑树的5个约束条件
            //旋转： 父亲是红色，叔叔是黑色时，进行旋转
            //如果当前节点是父亲的右节点，则进行左旋
+ @: N- @& h$ r* v, _1 `            //如果当前节点是父亲的左节点，则进行右旋

! O6 i! O+ s0 _- S0 V6 M: c            //moveRootToFront 方法是 把算出来的root放到根节点上
5 E0 c& l) I( [0 C9 |2 |) v                    return null;
                }
            }
        }

3 V& Q" N7 B# s/ _7 _$ _1 B2 i$ k首先判断新增的节点在红黑树上是不是已存在如果已存在就不在新增
如果节点没有实现Comparable接口，使用equals方法判断
, o  g/ Y7 O+ L如果节点已经实现Comparable接口，使用CompareTo判断
新增节点如果已经在红黑树上，直接返回；不在的话判断新增节点是在当前节点的左边还是右边，左边比当前值小，右边比当前值大。
递归前两步，知道当前节点的左子树或右子树为空时，停止递归，当前节点就是我们将要新增的父亲节点。
# D2 c. f% c0 c: \% A* M  G将新增节点放在当前节点的左边或是右边，与当前节点建立父子几点关系。
9 h5 R6 ~% ?3 \$ G8 }6 r2 H进行着色和旋转。

4 r  x& I( F# u1 H3 V2 I: ^get方法

0 n: c$ x8 Z2 B. J3 wpublic V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
0 h0 S; f" m) D. @& s    }

' B6 `3 u( m0 ~) b6 V- K$ C    /**
3 o' E" `9 ^7 b3 W     * Implements Map.get and related methods
: y- X: H0 `. y- S1 S# }     *
, n, T- I9 z5 e: j9 a0 {1 ~& b     * @param hash hash for key
+ ]2 u) i2 A1 ?& p     * @param key the key
     * @return the node, or null if none
     */
1 ~! }9 z, m2 G7 N6 B+ T    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
' [9 f, r: c6 ]3 v) z        //如果桶数组不为空，并且桶的长度>0,才进行下面的操作，否则就返回null
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //总是先检查第一个节点，如果第一个是我们要找的key就直接返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
* a6 p6 A7 B" m# l1 h2 C4 X) L                return first;
            if ((e = first.next) != null) {
            //如果first是TreeNode类型那就调用红黑树获取节点的方法
( T' }. h% t. V5 {                if (first instanceof TreeNode)
3 E/ y: L8 T0 g% }1 H: j                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
3 j& L: v/ i4 a. L* t5 A" B2 V6 U                //否则就是一链表的方式查找值
: Z( \2 l/ {$ P                do {
                //循环遍历，如果桶的hash和key与当前遍历的桶相等就返回。
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
! k! W: Z; ?; [7 w4 D& [                } while ((e = e.next) != null);
# T$ Z/ _% |1 h, p            }
        }
& W6 v; J: K, O  _3 |* C5 J" b        //以上都没找到就返回null
) m& z0 Q0 c/ p7 T& B        return null;
/ C3 q2 ^: P: K4 Z    }

查找主要分为三个步骤
. a' g2 G  ~; o/ `; K
根据hash算法定位数组的索引位置，找到key及其第一个元素。
通过equals方法判断第一个节点是否是我们需要的key,是的话直接返回，不是的话，往后遍历
6 \4 F$ O& s$ e, a, o判断当前节点的next是不是null，如果不是的话，再判断属于哪个类型，如果是红黑树就采用遍历红黑树的方法查找节点，否则就以遍历链表的方式查找
4 z0 p* v  x0 kresize方法
' J4 @% f1 C* B' c+ B
每次进行扩容，就会伴随着一次重新分配，并且会遍历hash表中的所有元素是非常耗时的。



( m, g0 I6 W' Bfinal Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        //如果旧的数组是null那他的容量就是0
& C5 d, S9 f* [" D8 i8 e: A) e        int oldCap = (oldTab == null) ? 0 : oldTab.length;
       //旧的扩容阀值
       int oldThr = threshold;
- M  E) G, y, g$ j        int newCap, newThr = 0;
$ b' ]9 v; q* B* d, w( r        if (oldCap > 0) {
$ ]( C  `+ q1 C7 H" I& l) G* A4 A) U; |        //如果已超过最大值不在进行扩容 ，直接返回旧数组
            if (oldCap >= MAXIMUM_CAPACITY) {
; [/ `- D, c$ m1 r4 O                threshold = Integer.MAX_VALUE;
                return oldTab;
1 \7 u- J  K1 j9 k& Q            }//没有超过最大值就扩容为原来的2倍，左移1位相当于乘2
& P" @; M" @) z5 F: t            //比如旧的容量是19,19>16,所以扩容为原来的两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
' U/ [) j! e; o4 J" y                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
        //
' q. o) Q" q5 d# x1 S& h: n3 J7 Z            newCap = oldThr;
' }" y5 k( H) r2 N6 ~" |        else {               // 调用默认构造方法创建的map第一次新增会走到这里进行判断
        //如果旧的数组的容量和扩容阀值都是0，就需要对新的map进行初始化,全部设置成默认值
            newCap = DEFAULT_INITIAL_CAPACITY;
# g- b/ H. O) Q% T! p  N- C            //threshold = loadFactor * capacity
/ a* j' I! t  }            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
% {, ~9 n( ^; [: l9 c1 c  J        }
        if (newThr == 0) {
       //如果新map的扩容阀值等于0，需要计算出扩容阀值，计算出的 阀值肯定不能大于最大容量，即使大于,最大也是Integer.MAX_VALUE
            float ft = (float)newCap * loadFactor;
  f" [4 t8 ]/ k1 T            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
/ C4 ]9 F/ b4 k8 p- A6 [        //进行赋值
        threshold = newThr;
2 N1 `+ V4 G$ @9 {9 D1 O2 F        //这里又新建了一个桶数组
5 f* q0 o) M+ h; [% |        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
5 s4 T8 }, Q' [! D5 N0 W        //如果旧的数组不为空，开始依次搬运桶
3 K# ]" i) g; L' C( |0 H        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;//临时变量e
                if ((e = oldTab[j]) != null) {
                //如果当前桶不为空将它赋值给临时变量, 并且将旧的数组中对应的值置为null,便于GC
                    oldTab[j] = null;
$ V0 P2 c2 e) m& b- t: g4 \                    //当第一个桶搬到新的数组中时他后面还没有其他桶
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
* o/ P% v& C2 K, K% ]7 D, O                    else if (e instanceof TreeNode)
8 H2 q# O  _1 c$ i; g# \                    //如果搬运的是树节点，将树分割成两棵树放入新数组中
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
6 h6 j& N1 |6 U                    else { // preserve order
                    //如果这个链表的长度>0且还没转换成树结构，那么扩容的时候就需要将这条链表转成两条链表
                        Node<K,V> loHead = null, loTail = null;
$ }0 z4 Y' [4 G                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
. u5 N/ f- u6 O/ u# L) G. c' P                            next = e.next;
: N1 n- A% f* p. {0 v& o                            //放在低位链表中
                            if ((e.hash & oldCap) == 0) {
# m( }" B! r$ H7 h5 y0 R                                if (loTail == null)
# g3 [% `1 r0 ]2 Q                                    loHead = e;
- S$ q; C* m/ q/ |) ^9 e/ F                                else
( `: @2 v; f2 ?4 e/ \, `( e0 q                                    loTail.next = e;
& C- @7 G* g, p8 j3 F0 n                                loTail = e;
                            }
  X% t% s9 v/ _: v* t                            else {
5 \4 ?, ]% v* d' s; q                            //放在高位链表中
                                if (hiTail == null)
" o5 W8 G0 g1 s                                    hiHead = e;
                                else
: Z( k+ t: \, x. k( c3 T; j                                    hiTail.next = e;
4 S0 G) t) R% y! v7 q$ z" R                                hiTail = e;
                            }
" [" `2 Z  j. d8 l$ [- c9 a# F& _                        } while ((e = next) != null);
                        //低位链表的桶在新数组的位置和之前一样
                        if (loTail != null) {
5 a' Q( T5 U7 F* E& \                            loTail.next = null;
; h; h; @# c$ e2 K                            newTab[j] = loHead;
9 Z1 T9 j% D* V3 ^. Q+ E  y/ J( x                        }
                        //高位链表在新数组的位置时原来的位置+oldCap
! U, {7 l/ |6 R: |0 h: V/ E8 w9 ?2 v                        if (hiTail != null) {
" |! A2 H+ B5 a                            hiTail.next = null;
7 K' A4 n" G& P: A3 F                            newTab[j + oldCap] = hiHead;
                        }
$ Y) b$ R) I! A9 ~) k2 c                    }
: `; R' t- G5 l' O                }
' r; |  X. |2 z0 z1 C) U' B            }
+ O+ z4 B5 ?9 n, X: Q7 P8 O        }
% x( [! `% a  h& k* [% R! e* r        return newTab;
2 Z8 x5 C8 v5 G( w8 \" m# L  [    }
/ h: \6 a! Y! q3 m$ H总结

HashMap在java8中的存储结构是： 数组+链表+红黑树
HashMap默认初始容量是 16，默认负载因子时0.75f,容量总是2的n次方，最大容量是2的30次方
HashMap扩容时每次容量变为原来的两倍
& m6 w' Q, W% j0 t0 P: q  h当链表长度大于等于8，但是桶的数量（数组的长度）小于64时，不会变成红黑树只会进行扩容
当红黑树的大小小于6时，会转变成链表
5 Y7 g; j: Y9 O% D. {1 ?, hHashMap是线程不安全的。在多线程使用场景中，应该尽量使用线程安全的ConcurrentHashMap替换HashMap，HashMap允许null做key。这样的key只能有一个但是null作为value可以有多个。
4 |* T; l" {/ }! |5 D. BHashMap查找和添加元素的时间复杂度都是O(1)

" @' c2 p) M% ?" F1 z  N8 ~



6 \. J  k) O+ [4 X

: {* {* D- w6 \
版权声明：本文为CSDN博主「java大涛」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
' [6 j% S- R7 p0 C' W原文链接：https://blog.csdn.net/qq_43672652/article/details/106035998
  x$ @& |& H+ b& j$ R! y% [; P
9 D2 v! W5 A0 n* W) c3 `
" T5 C9 M+ k% j6 Y$ G