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

目录

引言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 tvalue(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 fal;    }}

我们发现了这样的一个内容类，它是一个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, fal, 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 onlyifabnt,               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);    el {        node<k,v> e; k k;        if (p.hash == hash &&            ((k = p.key) == key || (key != null && key.equals(k))))            e = p;        el if (p instanceof treenode)            e = ((treenode<k,v>)p).puttreeval(this, tab, hash, key, value);        el {            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 (!onlyifabnt || oldvalue == null)                e.value = value;            afternodeaccess(e);            return oldvalue;        }    }    ++modcount;    if (++size > threshold)        resize();    afternodeinrtion(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;        }        el if ((newcap = oldcap << 1) < maximum_capacity &&                 oldcap >= default_initial_capacity)            newthr = oldthr << 1; // double threshold    }    el if (oldthr > 0) // initial capacity was placed in threshold        newcap = oldthr;    el {               // 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;                el if (e instanceof treenode)                    ((treenode<k,v>)e).split(this, newtab, j, oldcap);                el { // prerve 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;                            el                                lotail.next = e;                            lotail = e;                        }                        el {                            if (hitail == null)                                hihead = e;                            el                                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，所以一定会进入下面的分支：

el {               // 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，其中n抗病毒药ewcap就是本次需要创建的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,convenience va社团活动lue, 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();afternodeinrtion(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 (!onlyifabnt || 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方法的文章就介绍到这了,更多相关hashmapput方法内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！