面试之HashMap(二)

最新推荐文章于 2024-11-11 21:19:25 发布

CSRobot_

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量133

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/C8548/article/details/105380930

版权

Java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

大家好！我是CSRobot，从今天开始，我将会发布一些技术文章，内容就是结合春招以来的面试所遇到的问题进行分享，首先会对知识点进行一个探讨和整理，在最后会给出一些面试题并作出解答，希望可以帮助到大家！今天知识点是HashMap，今天来讲解JDK1.8版本下的HashMap。今天会分从以下几个方面进行探讨：

jdk1.8下HashMap重要属性
构造方法
put过程
面试题分享

一、HashMap

1、JDK1.8下的HashMap

在这里插入图片描述
JDK1.8下的HashMap相较于JDK1.7下最主要的变化就是新增了红黑树的实现方式。如果发生hash冲突，HashMap首先会将同一个桶中的数据以链表的形式存储，但是如果发生hash冲突的概率比较高，就会导致同一个桶中的链表长度过长，遍历效率降低，在JDK1.8中如果链表长度到达阀值(默认是8)，就会将链表转换成红黑树。

1）先看几个重要的参数

在其中最主要的参数和JDK1.7没有太大的区别，包括像初始容量等等，可以参考上一篇文章。这里主要讲述新增的一些参数属性

当链表转为红黑树的阙值，也就是当单链上节点数大于等于8时，该链转为红黑树

static final int TREEIFY_THRESHOLD = 8;

红黑树转为链表的阙值，也就是当单链上节点数小于等于6时，该链转为链表；

static final int UNTREEIFY_THRESHOLD = 6;

2）构造方法

HashMap的构造方法有三种，分别是无参构造，带容量的有参构造，带容量和loadfactor的有参构造；而在我们使用场景下一般都是使用无参构造。选择无参构造其实也是调用了默认的容量大小和默认的装载因子。

对于无参构造，那么只是指定装载因子，初始容量在插入元素之后进行指定。

对于有参构造，会使用tableSizeFor()方法指定扩容阙值的大小，不大于initialCapacity的最大2的幂次方数。

public HashMap() {
     this.loadFactor = DEFAULT_LOAD_FACTOR;
}

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

3）put过程

首先判断数组是否初始化，如果没有，进行初始化，初始容量16，阙值12
(n-1)&hash计算插入数组位置，如果该位置为空那么直接插入节点
如果不为空，那么判断该节点的类型，如果是红黑树，按照红黑树的插入方法
如果不是红黑树，遍历整个链表，如果没有相同的元素，那么在链表末尾插入新节点；如果有相同的元素，就替换并返回旧值
插入元素之后判断链表是否大于7，如果大于转为红黑树
插入完成之后判断节点数是否大于阙值，如果大于，那么扩容

public V put(K key, V value) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //当桶为null，进行初始化，resize方法完成了HashMap的初始化和扩容——见源码①
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //当要插入桶的位置为null，直接创建新节点插入该位置
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //当桶的链表首位置hash和key等于要插入的节点，直接替换
        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);
                    //临界值大于TREEIFY_THRESHOLD转为红黑树
                    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;
            }
        }
        //如果有旧值那么返回旧节点的value
        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()，初始化HashMap和扩容

这个方法比较长，前半段完成了HashMap的初始化，后半段完成了HashMap的扩容，具体见下面代码注释

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    //首先判断table是否为null，如果为null那么oldCap=0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //当oldCap大于0，
    if (oldCap > 0) {
        //此处判断oldCap是否越界，如果越界，直接返回旧Table
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //如果没有越界，对oldCap进行两倍扩容，并将threshold更新为原来的两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    //如果只是threshold大于0，说明初始化没有定义HashMap容量，此时直接将容量设为threshold
    else if (oldThr > 0)
        newCap = oldThr;
    //如果都没有指定，那么使用默认的容量16和阙值threshold
    else {
        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"})
    //此处一是对数组初始化，二是如果是扩容，那么创建两倍容量的新Table
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    //将旧Table中的节点转移到新Table中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //如果是单节点，直接插入到新Table中
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //如果该链是树结构，那么将树上的节点插入到新Table中
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //如果是链表，尾插法插入到新Table中
                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;
}

4）JDK1.8下的HashMap变化

**底层使用数组+链表+红黑树实现 **
初始化：无参构造只指定装载因子，不会进入到默认有参构造方法中，

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

//此时会定义threshold为大于initialCapacity的2次方数
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

key的hash计算

相较于JDK1.7简化了许多，直接使用key值的hash和它的高16位进行异或运算，保证了返回的hash值具有高16位和低16位的特征，避免了hash值冲突、插入数据冲突

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

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

哈希冲突时插入方法改为尾插法
JDK1.7是先扩容后插入，JDK1.8是先插入后扩容
如果链表小于等于6树还原转为链表，大于等于8转为树
1.7中扩容之后rehash，重新计算元素的位置，；在1.8中，两倍扩容，新的位置要么为原位置，要么为原位置+旧桶的长度（主要看新桶长度的1位置对应元素的Hash位置为1还是0，要是为1，位置=原位置+旧桶长度；否则为原位置不变）

在这里插入图片描述