Hashmap源码解析（jdk1.8）及面试问题

最新推荐文章于 2024-06-11 22:42:33 发布

疏雨过风林破

最新推荐文章于 2024-06-11 22:42:33 发布

阅读量1.3k

点赞数 1

分类专栏： java 文章标签：源码分析 Hashmap

本文链接：https://blog.csdn.net/ningchunmei1/article/details/80003107

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Hashmap源码分析

import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import sun.misc.SharedSecrets;

Hash table 是基于Map接口的实现。Hashmap的提供了所有可选的map操作并允许键和值为 null (除了不同步和允许空值，HashMap大致相当于Hashtable) Hashmap的遍历顺序是不确定的。
Hashmap的实例有两个影响其性能的参数：初始容量和加载因子，容量是哈希表中桶的数量，初始容量是哈希表创建时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。
当哈希表中的实体数量超过加载因子 * 容量时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），哈希表将扩容为大约两倍的桶数。
基本规则是默认加载因子为0.75，这样在时间和空间成本之间形成了一个良好的折中。
在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
如果有许多映射要存储在HashMap实例中，那么在创建哈希表时使用足够大的初始容量存储效率将高于根据需要增大表的大小执行自动重新散列。
Hashmap是线程不安全的，如果多个线程同时访问一个哈希映射，并且至少有一个线程修改映射结构，必须在外部进行同步操作。（结构修改是添加或删除一个或多个映射的操作，只是改变已经存在的实例的与关键字相关的值不是结构修改。）

fast-fail事件：当多个线程对Collection进行操作时，若其中某一个线程通过iterator去遍历集合时，该集合的内容被其他线程所改变；则会抛出ConcurrentModificationException异常。因此，当存在并发修改时，迭代器会快速失败。迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
//默认初始容量是16，必须是2的幂（为什么？后面介绍）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量，当使用带参构造函数指定初始容量时使用，避免指定的初始容量大于最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//桶的计数阈值，当添加元素时桶中的数量至少有这些时应该转换为树，而不是继续使用链表
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

哈希桶结点的定义

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//key的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 setValue(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 false;
        }
    }

计算key.hashCode()，高位运算
h = key.hashCode()为32位，将这32位的高16位于低16位进行异或运算，是高低bit都参与运算。二进制运算比模运算的效率要高。

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

Hashmap的带参构造函数分析：
如果初始容量小于0或者加载因子小于等于0都会抛出IllegalArgumentException异常
设置的初始容量大于最大容量时，将初始容量设置为最大容量。

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

get（）根据特定的key值返回value。通过hash（key）计算key的哈希值hash，(n - 1) & hash得到所在数组的位置。（n为数组的长度）首先比较第一个结点的hash值和key是否和计算的key的hash值和key相等，如果相等，返回第一个结点；否则一次比较链表中的其他结点。

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // always check first node
            if (first.hash == hash && 
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
            /**如果第一个结点是TreeNode的实例，说明此处不是链表，是红黑树的结构，则使用红黑树查找方法查找*/
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            /**否则遍历链表查找，知道找到或者查完链表为止*/
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

put（）将指定的建和值与map关联，即将此键值对放入map中。如果映射中原来有此键的映射，则将旧的值将会被替换。返回旧的值或者返回null。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
/**onlyIfAbsent如果为true，则不会改变已经存在的值*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        /**如果是第一次放键值对，那么table还没有初始化，或者table的长度是0，则resize（）进行初始化*/
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**如果table的这个位置为null表示还没有此索引的结点，应该先建一个结点存放此键值对*/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
       /**以上两种情况都不是，则依次对比链表中的结点（1）此键的结点已经存在，旧值换新值；（2）此处为树形结构，调用putTreeVal（）；（3）将此新结点放在链表末尾*/
        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);
                        //放入新节点后链表的节点数大于TREEIFY_THRESHOLD-1，则将链表树形化
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            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字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败
        ++modCount;
        /**放入新节点后HashMap中实际存在的键值对数量大于阈值，要rehash，扩容*/
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

resize（）初始化或者将table的长度翻倍,因为是二次幂扩展数组大小，所以每个桶中元素的位置或者是和原来相同的索引，或者是2的幂的距离移动到新的table中去。

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;
            }
         //扩充为原来的2倍newCap = oldCap << 1
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        // initial capacity was placed in threshold
        else if (oldThr > 0) 
            newCap = oldThr;
        // zero initial threshold signifies using defaults
        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"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //把每个bucket都移动到新的buckets中
        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;
/**原索引，为什么呢？如果原hash的后五位为01010，
*oldCap为10000,01010&10000 = 00000，即使newCap = oldCap<<1 = 100000,
*那么newCap-1后和hash的后五位与即11111&01010 = 00000，实际上是不变的*/
                            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);
                        // 原索引放到bucket里
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 原索引+oldCap放到bucket里
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

面试问题

1、HashMap的原理以及内部数据结构？
底层使用哈希表（数组加链表），当链表过长（结点达到8个）就转成红黑树以实现O（logn）时间复杂度内查找。
2、HashMap中put方法的过程？
（1）对key求哈希，在计算在table中的索引位置；
（2）如果没有碰撞，直接放入桶中；
（3）如果碰撞了，以链表的方式放在链表的后面；
（4）如果链表的长度超过阈值8，将链表转换成红黑树；
（5）如果结点已经存在，就新值替换旧值，并返回旧值；
（6）如果size > threshold，就要resize。
3、hash函数的实现？
高16位不变，低16位和高16位做异或；然后（n-1）&hash得到下标。

讲的很好的一片文章：http://www.importnew.com/20386.html

疏雨过风林破

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Hashmap源码解析（jdk1.8）及面试问题

Hashmap源码分析import java.io.IOException;import java.io.InvalidObjectException;import java.io.Serializable;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.ut...
复制链接

扫一扫

专栏目录