HashMap原理刨析

HashMap的数据结构：

数组+链表，jdk1.8以后就是数组+链表+红黑树（当链表的长度超过阈值的时候，阈值默认为8，然后将链表结构转换为红黑树结构）

HashMap的 put(k,v)方法

    public V put(K var1, V var2) {
        return this.putVal(hash(var1), var1, var2, false, true);
    }

    final V putVal(int var1, K var2, V var3, boolean var4, boolean var5) {
        HashMap.Node[] var6;
        int var8;
        if ((var6 = this.table) == null || (var8 = var6.length) == 0) {
            var8 = (var6 = this.resize()).length;
        }

        Object var7;
        int var9;
        if ((var7 = var6[var9 = var8 - 1 & var1]) == null) {
            var6[var9] = this.newNode(var1, var2, var3, (HashMap.Node)null);
        } else {
            Object var10;
            Object var11;
            if (((HashMap.Node)var7).hash == var1 && ((var11 = ((HashMap.Node)var7).key) == var2 || var2 != null && var2.equals(var11))) {
                var10 = var7;
            } else if (var7 instanceof HashMap.TreeNode) {
                var10 = ((HashMap.TreeNode)var7).putTreeVal(this, var6, var1, var2, var3);
            } else {
                int var12 = 0;

                while(true) {
                    if ((var10 = ((HashMap.Node)var7).next) == null) {
                        ((HashMap.Node)var7).next = this.newNode(var1, var2, var3, (HashMap.Node)null);
                        if (var12 >= 7) {
                            this.treeifyBin(var6, var1);
                        }
                        break;
                    }

                    if (((HashMap.Node)var10).hash == var1 && ((var11 = ((HashMap.Node)var10).key) == var2 || var2 != null && var2.equals(var11))) {
                        break;
                    }

                    var7 = var10;
                    ++var12;
                }
            }

            if (var10 != null) {
                Object var13 = ((HashMap.Node)var10).value;
                if (!var4 || var13 == null) {
                    ((HashMap.Node)var10).value = var3;
                }

                this.afterNodeAccess((HashMap.Node)var10);
                return var13;
            }
        }

        ++this.modCount;
        if (++this.size > this.threshold) {
            this.resize();
        }

        this.afterNodeInsertion(var5);
        return null;
    }

当调用put方法的时候，方法里边会调用putVal方法，需要key做hash操作，hash操作是把高16位hash值与低16位hash值做异或操作。
调用putVal方法时，会判断是否需要扩容，计算bucket中的index，做取模运算，如果该位置为，那么就以Entry对象的方式填入其中。
如果该index位置有数据，出现hash碰撞，进行链表操作，若链表的长度大于阈值，链表结构转换为红黑树结构进行存储。

HashMap的 get(obj)方法

public V get(Object var1) {
        HashMap.Node var2;
        return (var2 = this.getNode(hash(var1), var1)) == null ? null : var2.value;
    }

先计算key的hash值，进行取模运算获得buket中的index，如果发生hash碰撞，调用key.equals获取值。

HashMap的负载因子

static final float DEFAULT_LOAD_FACTOR = 0.75F;
hashMap的负载因子是为了扩容而存在的，如果当前hashMap的容量大于负载因子的容量，那么会进行扩容。

HashMap的长度为什么是2的n次幂?

当做取模运算的时候，减少hash碰撞问题

HashMap的扩容

static final int DEFAULT_INITIAL_CAPACITY = 16;
hashMap的默认容量为16，扩容会调用resize方法，扩容原来的两倍，移动重新计算hash进行存储。

如果两个键的hashcode相同，你如何获取值对象？

通过key.equals获取。