HashMap中数据添加过程

一、 哈希表的物理结构

HashMap和Hashtable底层都是哈希表(也称散列表),其中维护了一个长度为2的幂次方的Entry类型的数组table,数组的每一个索引位置被称为一个桶(bucket),你添加的映射关系(key,value)最终都被封装为一个Map.Entry类型的对象,放到某个table[index]桶中。

使用数组的目的是查询和添加的效率高,可以根据索引直接定位到某个table[index]。

二、HashMap中数据添加过程

     1.JDK7中过程分析

// 在底层创建了长度为16的Entry[] table的数组
HashMap map = new HashMap(); 

map.put(key1,value1);
/*
分析过程如下:

将(key1,value1)添加到当前hashmap的对象中。首先会调用key1所在类的hashCode()方法,计算key1的哈希值1,
此哈希值1再经过某种运算(hash()),得到哈希值2。此哈希值2再经过某种运算(indexFor()),确定在底层table数组中的索引位置i。
   (1)如果数组索引为i上的数据为空,则(key1,value1)直接添加成功   ------位置1
   (2)如果数组索引为i上的数据不为空,有(key2,value2),则需要进一步判断:
       判断key1的哈希值2与key2的哈希值是否相同:
         (3) 如果哈希值不同,则(key1,value1)直接添加成功   ------位置2
              如果哈希值相同,则需要继续调用key1所在类的equals()方法,将key2放入equals()形参进行判断
                (4) equals方法返回false : 则(key1,value1)直接添加成功   ------位置3
                      equals方法返回true : 默认情况下,value1会覆盖value2。

位置1:直接将(key1,value1)以Entry对象的方式存放到table数组索引i的位置。
位置2、位置3:(key1,value1) 与现有的元素以链表的方式存储在table数组索引i的位置,新添加的元素指向旧添加的元素。

...
在不断的添加的情况下,满足如下条件的情况下,会进行扩容:
if ((size >= threshold) && (null != table[bucketIndex])) :
默认情况下,当要添加的元素个数超过12(即:数组的长度 * loadFactor(加载因子)得到的结果 16*0.75)时,就要考虑扩容。默认扩容为原来的两倍。

补充:jdk7源码中定义的:
static class Entry<K,V> implements Map.Entry<K,V>
*/

map.get(key1);
/*
① 计算key1的hash值,用这个方法hash(key1)

② 找index = table.length-1 & hash;

③ 如果table[index]不为空,那么就挨个比较哪个Entry的key与它相同,就返回它的value
*/

map.remove(key1);
/*
① 计算key1的hash值,用这个方法hash(key1)

② 找index = table.length-1 & hash;

③ 如果table[index]不为空,那么就挨个比较哪个Entry的key与它相同,就删除它,把它前面的Entry的next的值修改为被删除Entry的next
*/

     2.JDK8中过程分析

下面说明是JDK8相较于JDK7的不同之处:

使用HashMap()的构造器创建对象时,并没有在底层初始化长度为16的table数组。


jdk8中添加的key,value封装到了HashMap.Node类的对象中。而非jdk7中的HashMap.Entry。


jdk8中新增的元素所在的索引位置如果有其他元素。在经过一系列判断后,如果能添加,则是旧的元素指向新的元素。而非jdk7中的新的元素指向旧的元素。“七上八下”


jdk7时底层的数据结构是:数组+单向链表。 而jdk8时,底层的数据结构是:数组+单向链表+红黑树。
红黑树出现的时机:当某个索引位置i上的链表的长度达到8,且数组的长度超过64时,此索引位置上的元素要从单向链表改为红黑树。

(为什么修改呢?红黑树进行put()/get()//remove()操作的时间复杂度为O(logn),比单向链表的时间复杂度O(n)好。性能更高。)


如果索引i位置是红黑树的结构,当不断删除元素的情况下,当前索引i位置上的元素的个数低于6时,要从红黑树改为单向链表。

三、HashMap源码剖析

        1.JDK1.7.0_07中源码

        2.JDK1.8.0_271中源码

1、Node

key-value被封装为HashMap.Node类型或HashMap.TreeNode类型,它俩都直接或间接的实现了Map.Entry接口。

存储到table数组的可能是Node结点对象,也可能是TreeNode结点对象,它们也是Map.Entry接口的实现类。即table[index]下的映射关系可能串起来一个链表或一棵红黑树。

2.属性

3.构造器
public HashMap() {
      this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted (其他字段都是默认值)
}
4.put()方法(难)
public V put(K key, V value) {
         return putVal(hash(key), key, value, false, true);
}

其中:

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; //oldTab原来的table
    //oldCap:原来数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //oldThr:原来的阈值
    int oldThr = threshold;//最开始threshold是0
    
    //newCap,新容量
	//newThr:新阈值
    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)
            //newCap = 旧的容量*2 ,新容量<最大数组容量限制
			//新容量:32,64,...
			//oldCap >= 初始容量16
			//新阈值重新算 = 24,48 ....
            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; //新容量是默认初始化容量16
        //新阈值= 默认的加载因子 * 默认的初始化容量 = 0.75*16 = 12
        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; //阈值赋值为新阈值12,24.。。。
    //创建了一个新数组,长度为newCap,16,32,64.。。
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) { //原来不是空数组
        //把原来的table中映射关系,倒腾到新的table中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {//e是table下面的结点
                oldTab[j] = null; //把旧的table[j]位置清空
                if (e.next == null) //如果是最后一个结点
                    newTab[e.hash & (newCap - 1)] = e; //重新计算e的在新table中的存储位置,然后放入
                else if (e instanceof TreeNode) //如果e是树结点
                    //把原来的树拆解,放到新的table
                    ((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;
                    //把原来table[i]下面的整个链表,重新挪到了新的table中
                    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.数组和 ArrayList 的区别

        ArrayList看做是对数组的常见操作的封装。

2.HashMap长度为什么是2的幂次方

        为了方便计算要添加的元素的底层的索引i。

3.HashMap底层是数组+链表,有数组很快了,为什么加链表?

        因为产生了哈希冲突。解决方案,使用链表的方式。保证要添加的元素仍然在索引i的位置上。

4.HashMap为什么长度达到一定的长度要转化为红黑树

        红黑树的常用操作的时间复杂度O(logn),比单向链表的O(n)效率高。

HashMap什么时候扩充为红黑树,什么时候又返回到链表?

        索引i的位置的链表长度超过8且数组长度达到64,需要索引i位置要变成红黑树。

当索引i的位置元素的个数低于6时,要红黑树结构转为单向链表。为什么?节省空间。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
HashMap是一种常用的数据结构,用于存储键值对。它通过哈希函数将键映射到存储桶,并使用链表或红黑树来解决哈希冲突。 下面是HashMap存储数据过程: 1. 当我们向HashMap插入一个键值对时,首先会根据键的哈希值计算出存储桶的索引位置。 2. 如果该索引位置上没有元素,则直接将键值对存储在该位置上。 3. 如果该索引位置上已经存在元素,则可能存在哈希冲突。HashMap使用链表或红黑树来解决哈希冲突。 - 如果链表长度小于8,则将新的键值对添加到链表的末尾。 - 如果链表长度大于等于8,则将链表转换为红黑树,以提高查找效率。 4. 当需要查找某个键对应的值时,HashMap会根据键的哈希值计算出存储桶的索引位置,并在该位置上进行查找。 - 如果该位置上是链表,则遍历链表进行线性查找。 - 如果该位置上是红黑树,则使用红黑树的查找算法进行查找。 5. 当需要删除某个键值对时,HashMap会根据键的哈希值计算出存储桶的索引位置,并在该位置上进行删除操作。 - 如果该位置上是链表,则遍历链表进行删除。 - 如果该位置上是红黑树,则使用红黑树的删除算法进行删除。 总结一下,HashMap通过哈希函数将键映射到存储桶,并使用链表或红黑树来解决哈希冲突。这样可以在常数时间内实现插入、查找和删除操作。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值