Java集合——HashMap（jdk1.7）

时间 2019-11-17

标签 java 集合 hashmap jdk1.7 jdk 栏目 Java 繁體版

原文原文链接

Java集合三大致系——List、Set、Map，而Set是基于Map实现的.在Map中HashMap做为其中经常使用类，面试中的常客.记得以前有次面试回答，HashMap是链表散列的数据结构，其容量是16，负载因子0.75，当大于容量*负载因子会进行2倍扩容，put操做是将key的hashcode值进行一次hash计算，key的equals方法找到键值对进行替换返回被旧数据，若没有找到会插入到链表中，HashMap线程不安全.当面试官听到这些之后第一个问题为何容量是16，1五、14不行吗？为何2倍扩容？为何HashMap建议不可变对象用Key？本身当时思考得不够深刻，还没问到ConcurrentHashMap我就已经心慌了...下面我来聊一聊我对HashMap的见解html

HashMap简述

继承关系

先看下HashMap的继承关系:
java

从图中能够看到HashMap实现了Map、Serializable、Cloneable接口，继承了AbstractMap抽象类.那么既然已经继承了AbstractMap，而AbstractMap实现了Map接口，这至关于hashmap已经实现了map接口，可为何Hashmap还要去实现Map接口，在集合中有不少这样的状况，网上找了下结构大体有如下答案:
①.添加Map接口声明是为了Class类的getInterfaces这个方法可以直接获取到Map接口
②.mistake是一个错误
③.为了java api的文档生成工具而优化，产生更精确的类型的文档

HashMap数据结构

1.7的HashMap采用数组+单链表实现，虽然HashMap定义了hash函数来避免冲突，但仍是会出现两个不一样的Key通过计算后桶的位置同样，HashMap采用了链表来解决，可若是位于链表中的结点过多，1.7的HashMap经过key值依次查找效率过低，因此在1.8中HashMap进行了改良，采用数组+链表+红黑树来实现，当链表长度超过阈值8时，将链表转换为红黑树.
再来看看Entry中有哪些属性，在1.8中Entry更名为Node，属性不变，1.8改动后面会说，主讲1.7

static class Entry implements Map.Entry {
        /** 贱对象*/
        final K key;
        /** 值对象*/
        V value;
        /** 指向下一个Entry对象*/
        Entry next;
        /** 键对象哈希值*/
        int hash;
    }    
复制代码

1.7 HashMap源码分析

HashMap关键属性

/**
     * 默认初始容量16——必须是2的幂
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
    
    /**
     * HashMap存储的键值对数量
     */
    transient int size;
    
    /**
     * 默认负载因子0.75
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
    /**
     * 扩容阈值，当size大于等于其值，会执行resize操做
     * 通常状况下threshold=capacity*loadFactor
     */
    int threshold;
    
    /**
     * Entry数组
     */
    transient Entry[] table = (Entry[]) EMPTY_TABLE;
    
    /**
     * 记录HashMap修改次数，fail-fast机制
     */
    transient int modCount;
    
    /**
     * hashSeed用于计算key的hash值，它与key的hashCode进行按位异或运算
     * hashSeed是一个与实例相关的随机值，用于解决hash冲突
     * 若是为0则禁用备用哈希算法
     */
     transient int hashSeed = 0;
复制代码

HashMap构造方法

/**
     * 指定容量及负载因子构造方法
     */
    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;
        //设置扩容阈值
        threshold = initialCapacity;
        //空方法，让其子类重写例如LinkedHashMap
        init();
    }
    
    /**
     * 默认构造方法，采用默认容量16，默认负载因子0.75
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    
    /**
     * 指定容量构造方法，负载因子默认0.75
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
复制代码

从这3个构造方法中咱们能够发现虽然指定了初始化容量大小，但此时的table仍是空，是一个空数组，且扩容阈值为初始容量.在其put操做前，会建立数组.node

/**
     * 根据已有Map构造新HashMap的构造方法
     * 初始容量:参数map大小除以默认负载因子+1与默认容量的最大值
     * 初始负载因子:默认负载因子0.75
     */
    public HashMap(Map m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);
        //把传入的map里的全部元素放入当前已构造的HashMap中
        putAllForCreate(m);
    }  
复制代码

这个构造方法即是在put操做前调用inflateTable方法，inflate意为膨胀，这个方法咱们来看下，注意刚也提到了此时的threshold扩容阈值是初始容量面试

private void inflateTable(int toSize) {
        //返回不小于number的最小的2的幂数，最大为MAXIMUM_CAPACITY
        int capacity = roundUpToPowerOf2(toSize);
        //设置扩容阈值，值为容量*负载因子与最大容量+1的较小值
        threshold = (int) Math.min(capacity * loadFactor,
                 MAXIMUM_CAPACITY + 1);
        //建立数组
        table = new Entry[capacity];
        //初始化HashSeed值
        initHashSeedAsNeeded(capacity);
    }
    
    /**
     * 返回不小于number的最小的2的幂数，最大为MAXIMUM_CAPACITY
     */
    private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        /**
         * 若number不小于最大容量则为最大容量
         * 若number小于最大容量大于1，则为不小于number的最小的2的幂数
         * 若都不是则为1
         */
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }
复制代码

从这里咱们能够到HashMap建立了一个2的幂数容量的数组，那为何必定要这样设计？后面我会介绍.算法

put方法

我往HashMap中添加元素调用最多就是这个put方法
public V put(K key, V value)
咱们来看下其代码实现:
shell

public V put(K key, V value) {
        //若数组为空时建立数组
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //若key为null
        if (key == null)
            return putForNullKey(value);
        //对key进行hash计算，获取hash值    
        int hash = hash(key);
        //根据刚获得的hash值与数组长度计算桶位置
        int i = indexFor(hash, table.length);
        //遍历桶中链表
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            //key值与hash值都相同的话进行替换
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                //空方法，让其子类重写例如LinkedHashMap
                e.recordAccess(this);
                //返回旧值
                return oldValue;
            }
        }
        //记录修改
        modCount++;
        //链表中不存在此键，则调用addEntry方法向链表中添加新结点
        addEntry(hash, key, value, i);
        return null;
    } 
复制代码

从上面的源码咱们能够看到:
①HashMap首先判断数组是否为空，若为空调用inflateTable进行扩容.
②接着判断key是否为null，若为null就调用putForNullKey方法进行put.因此HashMap容许Key为null
③再将key进行一次哈希计算，获得的哈希值和当前数组长度计算获得数组中的索引
④而后遍历该数组索引下的链表，若key的hash和传入key的hash相同且key的equals放回true，那么直接覆盖 value
⑤最后若不存在，那么在此链表中头插建立新结点
api

逐步来介绍(第一步就不说了上文已阐述过)，第二步最主要就是putForNullKey方法，从中咱们能够发现若key为null会先从0位置桶上链表遍历，若找到结点key为null的进行替换，不存在则添加结点.方法内的addEntry后续讲数组

private V putForNullKey(V value) {
        //遍历0位置桶上的链表，若存在结点Entry的key为null替换value，返回旧值
        for (Entry e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //若不存在，0位置桶上的链表中添加新结点
        addEntry(0, null, value, 0);
        return null;
    }
复制代码

第三步中先看下HashMap的hash算法，获取键对象哈希值并将补充哈希函数应用于该对象结果哈希，防止质量差的哈希函数，注意：空键老是映射到散列0，所以索引为0，1.8的hash方法已进行过优化，安全

final int hash(Object k) {
        // 当h不为0且键对象类型为String用此算法，1.8已删除
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h ^= k.hashCode();
        //此函数确保在每一个比特位置上仅以恒定倍数不一样的hashCode具备有限的碰撞数量（在默认负载因子下约为8）
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }  
复制代码

根据所计算的值与数组长度计算桶位置:数据结构

static int indexFor(int h, int length) {
        return h & (length-1);
    } 
复制代码

此方法对数组的长度取模运算，获得的余数进行下表访问，那么既然是取模运算为何不直接h%length，由于其效率很低，因此采用位运算.从中咱们能够看出，假设length为16，当咱们h为1，17时算出桶的索引都为1这种状况就称为冲突(k1≠k2，而f(k1)=f(k2)).当有冲突时HashMap采用链地址法(把全部的同义词用单链表链接起来的方法)处理冲突
其次假设length分别为16，15，14时，他们的冲突次数:

length = 16			length = 15			length = 14
h	h&length-1	结果	h&length-1	结果	h&length-1	结果
0	0000 & 1111	0000	0	0000 & 1110	0000	0000 & 1101	0000
1	0001 & 1111	0001	1	0001 & 1110	0000	0001 & 1101	0001
2	0010 & 1111	0010	2	0010 & 1110	0010	0010 & 1101	0000
3	0011 & 1111	0011	3	0011 & 1110	0010	0011 & 1101	0001
4	0100 & 1111	0100	4	0100 & 1110	0100	0100 & 1101	0100
5	0101 & 1111	0101	5	0101 & 1110	0100	0101 & 1101	0101
6	0110 & 1111	0110	6	0110 & 1110	0110	0110 & 1101	0100
7	0111 & 1111	0111	7	0111 & 1110	0110	0111 & 1101	0101
8	1000 & 1111	1000	8	1000 & 1110	1000	1000 & 1101	1000
9	1001 & 1111	1001	9	1001 & 1110	1000	1001 & 1101	1001
10	1010 & 1111	1010	10	1010 & 1110	1010	1010 & 1101	1000
11	1011 & 1111	1011	11	1011 & 1110	1010	1011 & 1101	1001
12	1100 & 1111	1100	12	1100 & 1110	1100	1100 & 1101	1100
13	1101 & 1111	1101	13	1101 & 1110	1100	1101 & 1101	1101
14	1110 & 1111	1110	14	1110 & 1110	1110	1110 & 1101	1100
15	1111 & 1111	1111	15	1111 & 1110	1110	1111 & 1101	1101
0个冲突			8个冲突			8个冲突

从中咱们就能够知道为何不是15，14而必需要是2的幂数，length为16时在[0,15]区间内冲突为0，且雨露均沾分布均匀每一个桶均可能会存放数据，而为15，14时不只有冲突并且有些空间永远不会存放数据这就致使了资源浪费，而且散列就不会出现下标越界获得一个异常.
那么初始容量为何要为16，而不是8，32呢？我认为如果8的话扩容阈值为6，没放几个就会扩容;而32的话又不会放那么多，资源浪费.

第四步中若key的hash和传入key的hash相同且key的equals放回true，那么直接覆盖value.key的hash值是根据其hashcode值进行hash哈希计算获得的，那么当咱们用可变对象时其hashcode值很容易会变化，那么就会带来风险找不到原来的value，因此HashMap建议使用不可变对象做为Key

最后一步addEntry方法建立新结点，代码以下

void addEntry(int hash, K key, V value, int bucketIndex) {
        //当前hashmap中的键值对数量超过扩容阈值，进行2倍扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //2倍扩容
            resize(2 * table.length);
            //扩容后，桶的数量增长了，从新对键进行哈希码的计算
            hash = (null != key) ? hash(key) : 0;
            //根据键的新哈希码和新的桶数量从新计算桶索引值
            bucketIndex = indexFor(hash, table.length);
        }
        //建立结点
        createEntry(hash, key, value, bucketIndex);
    }
    
    /**
     * 头插结点
     * 将本来在数组中存放的链表头置入到新的Entry以后，将新的Entry放入数组中
     */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
复制代码

先不看扩容状况，当不须要扩容时，hashmap采用头插法插入结点，为何要头插而不是尾插，由于后插入的数据被使用的频次更高，而单链表没法随机访问只能从头开始遍历查询，因此采用头插.忽然又想为何不采用二维数组的形式利用线性探查法来处理冲突，数组末尾插入也是O(1)，可数组其最大缺陷就是在于若不是末尾插入删除效率很低，其次若添加的数据分布均匀那么每一个桶上的数组都须要预留内存.
再来看看扩容:

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //建立新的数组
        Entry[] newTable = new Entry[newCapacity];
        //将旧Entry数组转移到新Entry数组中去
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        //从新设置扩容阈值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    } 
复制代码

transfer方法遍历旧数组全部Entry，根据新的容量逐个从新计算索引头插保存在新数组中，扩容至关麻烦，因此若是当咱们知道须要添加多少数据时最好指定容量初始化.

/**
     * 将旧Entry数组转移到新Entry数组中去
     */
    void transfer(Entry[] newTable, boolean rehash) {
        //获取新数组的长度
        int newCapacity = newTable.length;
        for (Entry e : table) {
            while(null != e) {
                Entry next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                //从新计算索引
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }  
复制代码

在这里可能会出现环形链表致使死循环.先假设容量为4，负载因子默认0.75，扩容阈值3，HashMap当前存储以下:

单线程状况下若再添加一个元素，HashMap会扩容从新布局可能以下:

那当咱们多线程操做HashMap呢？
假定有两个线程同时要添加数据到此HashMap，在扩容时 Thread1正准备处理Entry1，执行完Entry<K,V> next = e.next挂起执行Thread2，此时E为Entry1，next为Entry2
Thread2执行完transfer方法

此时Thread1恢复执行，
将Entry1插入到新数组中去，而后e为Entry2，轮到下次循环时next因为Thread2的操做变为了Entry1

由于Thread2执行过整个transfer方法因此Entry2和Entry1在新散列表中必定会再次冲突，而后将Entry2头插链表，再次e为Entry1，next为null

因为头插Entry1插入链表，将Entry1指向了Entry2，此时环形链表出现了，当咱们操做环形链表的桶就会gg.也由于HashMap本就线程不安全，因此sun不认为这是个问题，如有并发场景就用ConcurrentHashMap

另外这让我想起一道经典面试题链表反转，本身动手实现了下

public class Node {

    private Node next;

    private Object item;

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }

    public static Node get(){
        Node last = new Node(6, null);
        Node fifth = new Node(5,last);
        Node fourth = new Node(4, fifth);
        Node third = new Node(3, fourth);
        Node second = new Node(2, third);
        Node first = new Node(1, second);
        return first;
    }

    public static void outPut(Node node){
        while(node != null){
            System.out.print(node.item);
            node = node.next;
        }
    }

    public static Node reverse(Node node){
        Node newNode = node;
        Node temp = null;
        while (node != null && node.next != null){
            Node next = node.next;
            node.next = temp;
            temp = node;
            newNode = new Node(next.item, node);
            node = next;
        }
        return newNode;
    }

    public static void main(String[] args) {
        Node first = get();//获取单链表头结点
        outPut(first);//输出整条链表数据
        first = reverse(first);
        outPut(first);
    }
} 
复制代码

get方法

知道了put原理，get操做就很好理解了，先看下代码:

/**
     * 返回到指定键所映射的值，若不存在返回null
     */
    public V get(Object key) {
        //与put同样单独处理
        if (key == null)
            return getForNullKey();
        Entry entry = getEntry(key);
        return null == entry ? null : entry.getValue();
    } 
复制代码

与存null key同样，从0位置上的桶上获取

private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    } 
复制代码

getEntry

final Entry getEntry(Object key) {
        //size为0，即hashmap为空，返回null
        if (size == 0) {
            return null;
        }
        //对key进行hash计算，获取hash值
        int hash = (key == null) ? 0 : hash(key);
        //根据hash值与数组长度获取桶位置，遍历对应桶上链表
        for (Entry e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //key值与hash值都相同的话返回结点
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        //若不存在返回null
        return null;
    } 
复制代码

小结

本篇主要围绕着java7HashMap源码讲解其原理作个小结:
①由于其put操做对key为null场景作了单独处理，因此HashMap容许null做为Key
②由于HashMap在算桶index时根据key的hashcode值进行hash计算获取hash值与数组length-1进行与运算，length-1的二进制位全为1，这样能够分布均匀避免冲突，因此HashMap容量要为2的幂数
③由于HashMap的操做会围绕key的hashcode进行hash计算，而可变对象其hashcode很容易变化，因此HashMap建议用不可变对象做为Key.
④HashMap线程不安全扩容方法可能会致使环形链表死循环，因此若须要多线程场景下操做可使用ConcurrentHashMap
⑤.当发生冲突时，HashMap采用链地址法(拉链法)处理冲突，而后根据key的hash以及equals方法具体获取key所对应的Entry
⑥.为何HashMap初始容量定为16，我认为如果8的话扩容阈值为6，没放几个就会扩容;而32的话又不会放那么多，资源浪费

参考

https://coolshell.cn/articles/9606.html http://www.cnblogs.com/chenssy/p/3521565.html