HashMap

LoadFactor

负载因子,默认为0.75

threshold

所能容纳键值对的临界值,计算公式为数组长度*负载因子

size

hashMap中实际的键值对数量

modCount

用来记录hashmap内部结构发生变化的次数

hashMap的默认容量INITIAL_CAPACITY为16

TREEIFY_THRESHOLD

树化阈值(超过8之后,链表升级为树)

UNTREEIFY_THRESHOLD

存储结构

HashMap采用了数组+链表+红黑树的存储结构

数组部分称为哈希桶,当链表长度大于8时将采用红黑树进行存储,当长度降到6时,转成链表

链表的时间复杂度为o(n)

红黑树的时间复杂度为o(logn)

node节点的数据结构

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

Node实现了Map.Entry 接口,本质是一个键值对

数据插入

当向hashMap中插入数据时,首先要确定在hash桶中的具体位置。那么如何确定node的存储位置呢

  1. 获取key的hash值

  2. 经过hash值扰动函数,使得hash值更散列,

    hashmap还没扩容很大的时候,length很小,而 index = (length-1)& hashcode,让hash值的高位也参与寻址计算

  3. 构造node对象

  4. 路由算法,找出node应存放的位置(路由寻址公式:(table.length-1)&node.hash)

Hash碰撞

hash值相同时,put放入对应链表中。一直碰撞,查找低效。

什么是链化

红黑树解决链化问题,提高查找效率

扩容原理

原因:如果hash表元素很多,get的时候,理想情况是o(1),链化严重的话,变成o(n)了,扩容就是使数组变大,使元素分散。

为了解决hash冲突,导致链化严重,为了提高查找性能,空间换时间,

1.简述put方法:

  1. ​ 首先检查数组是否为空,为空的时候需要调用扩容方法,初始化一个长度为16,阈值为8的数组

  2. ​ 计算key’的hash值,hash值&(桶长度-1)找到应该在桶中存储的位置,

  3. ​ 如果桶中这个位置的元素为空,则直接赋值

  4. ​ 如果不为空,则比较key是否相等,相等的话满足条件覆盖

  5. ​ 如果key值不相等,比较类型为红黑树,则调用红黑树的插入,类型为链表,则采用尾插法插入。

  6. ​ 插入完成后,查看map的size是否大于阈值,大于阈值,则要扩容

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

简述resize方法

  1. ​ 如果数组为空,则新建一个默认长度为16,阈值为8的数组并返回

  2. ​ 如果数组不为空,说明里面有数据,首先检查数组长度是否大于最大长度,如果超过,则将阈值设为整形最大值,表示不再扩容

  3. ​ 否则将数组长度2,阈值大小 *2 建立一个新table。

  4. ​ 然后需要将原来table的数据,转移到新的table中。遍历oldTable 如果里面的首元素不为空,如果该元素指向的下一个元素为空, 根据路由算法,计算该元素在新数组中的位置index,直接赋值给新table

  5. 如果该元素指向的下一个元素不为空,并且该元素类型为链表,则遍历该链表,这里位置可能是index,也有可能是index+oldLength.

    这里有一个简易算法,直接hashcode&newLength,为0则采用尾插法,插入低位链index,为1,则采用尾插法插入高位链index+oldLength

    6.类型为红黑树,会把数据先拿出来放到新表中,如果新表会不会有红黑树取决于数据放进去之后,而不是把整个红黑树移动过去;其实和链表也差不多,它也会先分成两个链,高位链和低位链,然后把链放到新表中;

 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;
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值