HashMap1.8小结

最新推荐文章于 2023-08-02 21:46:09 发布

wu_佳佳布鲁根

最新推荐文章于 2023-08-02 21:46:09 发布

阅读量130

点赞数

分类专栏： Java Android 文章标签： Android

本文链接：https://blog.csdn.net/wuhongji2017/article/details/100137570

版权

Java 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

Android

4 篇文章 0 订阅

订阅专栏

这几天看了下HashMap，从源码的角度出发，分析HashMap的工作原理，以及会遇到的问题。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
}

这一行代码中就能看出来HashnMap是 AbstractMap的子类，实现了Map接口。直接看源码HashMap的几个属性，通过属性的注释，来了解下，几个属性的意义：

/**
 * 默认初始容量16，必须是2的幂
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
 * 最大容量  必须是2的幂，小于=1<<30(移位运算符) 1 073 741 824
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 负载因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 这是个阈值，当元素添加的时候大于等于这个阈值的时候将转换为红黑树结构
 */
static final int TREEIFY_THRESHOLD = 8;

/** * 默认阈值6，当元素个数小于等于6的时候又转换成链表 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 *哈希标，长度为2的幂
 */
transient Node<K,V>[] table;

/** *哈希表的阈值，当长度超过这个值的时候，发生扩容resize */
int threshold =0.75数组长度;

然后我们开始看构造方法

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

无参构造方法，将负载因子赋值。

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);}

第二个构造方法，调用了本身两个参数的构造方法，并且将参数传入，初始长度为initialCapacity

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)//如果长度小于0，抛异常
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)//如果长度大于MAXIMUM_CAPACITY
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))//如果负载因子<0或者不是数字时，异常
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

tableSizeFor方法就是比如传入一个18，2的4次方是16，返回的就是2的五次方32.

也就是说当我们进行初始化的时候，我们就建立了一个长度固定，可扩容的数组。

那么HashMap是如何put值得呢？

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

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //底层存储数据的数组tab为空，进行第一次扩容，同时初始化tab
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //计算要存储数据的下标index，如果当前位置为null，直接插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        //tab[i]的首个元素就是key，直接覆盖
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //tab[i]为TreeNode，进行红黑树的插入
        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);
                    //链表长度大于8，转换为红黑树进行处理
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //找到已经存在的key，直接覆盖
                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;
    //数据插入完成，size超过了扩容的阀值(容量*负载因子)，进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

static final int hash(Object key) {
    int h;
    //通过hashCode()的高16位异或低16位实现
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

也就是说初始化的时候我们建立个默认长度的数组，当put值的时候，我们对值取hashCode，然后对hashCode进行位运算，得到下标，存入相应的桶子中。而且put的时候还会进行一些判断，具体请看上述源码的写的注释。

上述还说了一个问题：扩容。扩容是什么？就是当你存储量超过了我现有的数组的时候，我需要扩大数组，也就是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) {
                //超过数组在java中最大容量就无能为力了，冲突就只能冲突
                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
            }
            //...... ......
            //更新新的最大容量为扩容计算后的最大容量
            threshold = newThr;
            //更新扩容后的新数组长度
            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;
                    //如果老数组对应索引上有元素则取出链表头元素放在e中
                    if ((e = oldTab[j]) != null) {
                        oldTab[j] = null;
                        //如果老数组j下标处只有一个元素则直接计算新数组中位置放置
                        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
                            //能进来说明数组索引j位置上存在哈希冲突的链表结构
                            Node<K, V> loHead = null, loTail = null;
                            Node<K, V> hiHead = null, hiTail = null;
                            Node<K, V> next;
                            //循环处理数组索引j位置上哈希冲突的链表中每个元素
                            do {
                                next = e.next;
                                //判断key的hash值与老数组长度与操作后结果决定元素是放在原索引处还是新索引
                                if ((e.hash & oldCap) == 0) {
                                    //放在原索引处的建立新链表
                                    if (loTail == null) loHead = e;
                                    else loTail.next = e;
                                    loTail = e;
                                } else {
                                    //放在新索引（原索引 + oldCap）处的建立新链表
                                    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;
        }

其实hashmap扩容的时候除了在初始化之后，其实是有个阈值，这个值是负载因子*当前数组长度，当大于这个值的时候发生扩容，也就是0.75倍当前数组长度，发生扩容，扩容的的时候需要rehash和resize。

那么考虑一个问题，为什么负载因子是0.75？因为当小于0.75的时候会经常扩容，时间上非常耗时，当大于0.75的时候扩容的量比较大，比较占空间，所以根据泊松分布计算，0.75是个最优解。

下面有几个问题需要考虑下，也是面试经常会问到的

hash冲突是怎么造成的，如何解决？
多线程的情况下，hashMap扩容的时候会造成什么影响？
hashmap1.7和1.8的不同
为什么在解决hash冲突的时候，不直接用红黑树?而选择先用链表，再转红黑树?
我不用红黑树，用二叉查找树可以么?

如果两个 Entry的 key的 hashCode()返回值相同，那它们的存储位置相同。如果这两个 Entry的 key通过equals比较返回 true，新添加 Entry的 value将覆盖集合中原有 Entry的 value，但key不会覆盖。如果这两个 Entry的 key通过equals比较返回 false，新添加的 Entry将与集合中原有 Entry形成 Entry链，而且新添加的 Entry位于 Entry链的头部。
HashMap在多线程下会形成环形链表，造成死循环（1.7），，1.8解决了死循环的问题，但是还是会造成put不是null，getnull的问题
由数组+链表的结构改为数组+链表+红黑树。优化了高位运算的hash算法，扩容后，元素要么是在原位置，要么是在原位置再移动2次幂的位置，且链表顺序不变。
因为红黑树需要进行左旋，右旋，变色这些操作来保持平衡，而单链表不需要。当元素小于8个当时候，此时做查询操作，链表结构已经能保证查询性能。当元素大于8个的时候，此时需要红黑树来加快查询速度，但是新增节点的效率变慢了。因此，如果一开始就用红黑树结构，元素太少，新增效率又比较慢，无疑这是浪费性能的

wu_佳佳布鲁根

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HashMap1.8小结

这几天看了下HashMap，从源码的角度出发，分析HashMap的工作原理，以及会遇到的问题。public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {} 这一行代码中就能看出来HashnMap是Abst...
复制链接

扫一扫