解析HashMap中的put方法执行流程

引言

在java集合中，hashmap的重要性不言而喻，作为一种存储键值对的数据结构，它在日常开发中有着非常多的应用场景，也是面试中的高频考点，本篇文章就来分析一下hashmap集合中的put方法。

hashmap底层数据结构

先来了解一下hashmap底层的数据结构，它实质上是一个散列表，在数据结构课程中，我们应该都学习过散列表，它是通过关键码值而直接进行访问的一种数据结构，比如存储这样的一个序列：5,12,7,6,1,3。我们首先需要设定一个hash函数，通过该函数就能够定位每个元素存储的位置，比如hash函数为 h(k) = k % 6，那么每个元素的存储位置即为：1,0,1,0,1,3，此时问题就出现了，有几个元素的存储位置计算后发现是一样的，而一个位置不可能存放两个值，这就是hash冲突。
解决哈希冲突的方式有很多：

• 线性探测法
• 伪随机数法
• 链地址法

若是采用较为简单的线性探测法，则将产生冲突的元素向后移动一个位置，若是仍然有冲突，则继续后移一位，由此可得每个元素的存储位置：

在hashmap中，它的设计当然是要精妙很多的，查阅其源码：

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

我们发现了这样的一个内容类，它是一个node节点，由此，我们可以猜测，hashmap对于冲突的解决办法采用的是链地址法，那么hashmap数据的真正存放位置是在哪呢？

transient node<k,v>[] table;

就是这样的一个node数组。

put方法的执行流程

我们直接通过一个程序来理解hashmap中put方法的执行流程，在put方法中，hashmap需要经历初始化、存值、扩容、解决冲突等等操作：

public static void main(string[] args) {
    map<string, string> map = new hashmap<>();
    map.put("name", "zs");
    map.put("age", "20");
    map.put("name", "lisi");
    map.foreach((k, v) -> {
        system.out.println(k + "--" + v);
    });
}

这段程序的运行结果我们都知道是name--lisi age -- 20，那为什么是这个结果呢？源码能够告诉我们答案。

首先执行第一行代码，调用hashmap的无参构造方法：

public hashmap() {
    this.loadfactor = default_load_factor; // all other fields defaulted
}

在构造方法中，只是设置了一个loadfactor的成员变量，它表示的是hash表的负载因子，默认值为0.75，至于这个负载因子是什么，我们后面再说。
接下来程序会执行put方法：

public v put(k key, v value) {
    return putval(hash(key), key, value, false, true);
}

put方法又调用了putval方法，并传入了key的hash，key，value等等参数，所以先来计算key的hash：

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

这个hash是用来计算插入位置的，我们放到后面说，计算完key的hash后，它将调用putval方法：

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

该方法的前三行先定义了一个node类型的数组和一个变量，并判断类成员中的table是否为空，前面我们已经说到，这个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;
    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;
                    node<k,v> hihead = null, hitail = null;
                    node<k,v> 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;
}

这个resize方法其实是相当复杂的，但我们捡出重要的代码来看，因为table的初始值为null，所以一定会进入下面的分支：

else {               // zero initial threshold signifies using defaults
    newcap = default_initial_capacity;
    newthr = (int)(default_load_factor * default_initial_capacity);
}

它设置了两个变量的值，newcap = 16，newthr = 0.75 * 16 = 12，其中newcap就是本次需要创建的table数组的容量，而newthr就是实际只能存储的容量大小。

对于一个散列表，如果让其每个位置都占满元素，那么一定是已经产生大量的冲突了，但若是只让小部分位置存储元素，又会浪费散列表的空间，由此，前辈们经过大量的计算，得出散列表的总容量 * 0.75之后的值是散列表最合适的存储容量，这个0.75就被称为散列表中的负载因子。所以，hashmap在第一次调用put方法时会创建一个总容量为16的node类型数组（前提是调用无参构造方法），但实际上只有12的容量可以被使用，当第13个元素插入时，就需要考虑扩容。

接下来就是初始化table数组：

threshold = newthr;
@suppresswarnings({"rawtypes","unchecked"})
node<k,v>[] newtab = (node<k,v>[])new node[newcap];
table = newtab;

通过调用resize方法，我们就获得了一个容量为16的node数组，紧接着就执行：

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newnode(hash, key, value, null);

还记得这个hash变量吗？它就是前面求得的key的hash值，通过n（table数组的长度，即：16）减1并与hash值做一个与运算，即可得到该数据的存储位置，它类似于文章开篇提到的hash函数 h(k) = k % 6，它做的也是这个操作，hash % n。需要注意，若是求模操作中，除数是2的幂次，则求模操作可以等价于与其除数减1的与操作，即：hash & (n - 1)，因为&操作的效率是要高于求模运算的，所以hashmap会将n设计为2的幂次。

求得数据需要插入的位置后，就需要判断当前位置是否有元素，现在table数组中没有任何数据，所以第一次判断一定是null，符合条件，执行代码：tab[i] = newnode(hash, key, value, null);，创建了一个节点，并存入hash值，key、value及其指针域：

node<k,v> newnode(int hash, k key, v value, node<k,v> next) {
    return new node<>(hash, key, value, next);
}

最后执行：

++modcount;
if (++size > threshold)
    resize();
afternodeinsertion(evict);

判断当前容量size是否超过了阈值threshold，若是超过了，还需要调用resize方法进行扩容。
到这里，第一个数据name:zs就插入成功了。

第二个数据age:20在这里就不作分析了，它和name的插入流程是一样的，我们分析一下第三个数据name:lisi的插入，这里涉及到了一个key重复的问题，来看看hashmap是如何处理的。

首先仍然是调用putval方法，并计算key的hash值，然后判断当前table是否为空，这次table肯定不为空，所以直接走到：

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newnode(hash, key, value, null);

仍然通过(n - 1) & hash计算数据的插入位置，结果发现要插入的位置已经有元素了，就是name:zs，此时就产生了冲突，执行：

node<k,v> e; k k;
if (p.hash == hash &&
    ((k = p.key) == key || (key != null && key.equals(k))))
    e = p;

现在的p就是name:zs，通过p的hash与当前数据key的hash比较，发现hash值相同，继续比较p的key，即：name与当前数据的key是否相同，发现仍然相同，此时就将p交给e管理，最后执行：

if (e != null) { // existing mapping for key
    v oldvalue = e.value;
    if (!onlyifabsent || oldvalue == null)
        e.value = value;
    afternodeaccess(e);
    return oldvalue;
}

此时e不为null，所以将e中的value值设置为当前数据的value值，由此，hashmap便成功将key为name的值修改为了lisi，并返回了原值zs。

总结

综上所述，我们能够得到以下结论：

• hashmap的总容量一定是2的幂次方，即使通过构造函数传入一个不是2的幂次方的容量，hashmap也会将其扩充至与其最接近的2的幂次方的值；比如传入总容量为10，则hashmap会自动将容量扩充至16
• 若是调用hashmap的无参构造方法，则将在第一次执行put方法时初始化一个总容量为16，实际可用容量为12的node数组
• 当实际容量超过阈值时，hashmap会进行扩容，扩容至原容量的2倍
• hashmap的put方法执行流程：首先判断当前table是否为空，若为空，则初始化，若不为空，则根据key的hash计算得到插入位置，再判断该位置是否有元素，若无元素，则直接插入，若有元素，则判断原位置数据的hash值与待插入数据的hash值是否相同，若相同，则继续比较值，若值不同，则创建一个新的node节点，并使用尾插法将其插入到原数据的节点后面形成链表，若值相同，则采用待插入数据的值覆盖原数据的值，并返回原数据的值
• hashmap采用链地址法解决hash冲突，所以当某个链表的长度大于8，并且table数组的长度大于64，则当前链表会被转换为红黑树，若table数组的长度尚未达到64，则进行扩容；当链表长度小于6，则会将红黑树转回链表
• 因为hashmap会根据key的hash值计算插入位置，所以key的数据类型一定要重写hashcode方法，否则会出现两个相同的key结果hash值不相同的情况，也需要重写equals方法，否则equals方法将比较的是地址值

到此这篇关于解析hashmap中的put方法的文章就介绍到这了,更多相关hashmap put方法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！