集合浅谈之HashMap篇

简介

• HashMap<K,V>采用了数组+链表的数据结构,它存储的内容是键值对 key-value 映射,继承了数组的线性查找和链表的寻址修改,具备较高效率
• HashMap<K,V>中的元素因为按照key的hash值进行存放故其中的元素是无序的,当发生hash冲突(即两个元素非同一个元素,但是key通过hash函数得到相同的值)时，采用链地址发解决hash冲突
• HashMap与Hashable基本相同,不同处为HashMap允许 null键和null值,并且HashMap<K,V>是线程不安全的

源码分析

由于红黑树部分较为复杂,本文不涉及红黑树的部分

基本成员变量部分

//实现了Map<K,V>, Cloneable, Serializable 接口
//迭代器对HashMap迭代的性能与hashMap的容量和键值对数成正比,因此注重迭代器性能时不要设置过大的初始容量和过小的加载因子
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{

 /**
    成员变量
    */
     // 16 默认容量,容量必须为2的幂
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
   //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;     
    //默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;    
     //扩容的阈值
    int threshold;  
   //在第一次使用时初始化
    transient Node<K,V>[] table;

	//内部Node<K,V>节点
    static class Node<K,V> implements Map.Entry<K,V> {
        //hash值,键以及值
        final int hash;
        final K key;
        V value;
     //链表结构，指向下一个Node键值对
        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; }
        //重写Object类中的toString()与hashcode()方法
        public final String toString() { return key + "=" + value; }
        public final int hashCode() {
            //^为位异或运算符,两个数从高位到低位进行比较,相同则为0,不同则为1
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
       //重写equals()方法
        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;
        }
    }
}

hash()方法

先思考一个问题，既然在Java中equals()方法就能确定两个对象是否相等，那么为什么还要存在hashcode哪，hashcode有什么作用？

在Java的集合框架设计中，某些集合(Set Map)等不允许存在重复的元素，当然可以使用equals()函数确保这些集合中不会存在重复元素，但是当集合中已经存在大量的数据，如果采用equals方法去逐一比较，效率必然是一个问题，那么如果采用hashcode，添加对象时先得到这个对象的hashcode，判断集合中是否存在这个hashcode，如果存在再调用equals()方法判断是否为同一个对象，如果为同一个对象，进行值的替换并返回旧值，不存在则添加新对象到对应位置，使用hashcode会有更好的效率。

  //hash函数(扰动函数),尽量使得不同的key得到不同的hash值,减小hash冲突的概率,提高程序性能
    /**
    1.首先判断键是否为null,如果为null则返回0
    2.若键不为null,则取键的hashcode与键的hashcode()无符号位右移16进行异或得到最终hash值(低16位与高16位异或)
    */
    static final int hash(Object key) {
        int h;
        //     >>>无符号右移，忽略符号位，空位都以0补齐
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

接下来分析HashMap的构造方法

 //无参构造方法,使用默认值
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    
  //该构造方法实际调用指定容量与指定加载因子的构造函数
  public HashMap(int initialCapacity) {
        this(initialCapacity, 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;
        //得到大于当前容量的最小的2的幂
        this.threshold = tableSizeFor(initialCapacity);
    }


//看一下神奇的tableSizeFor(int cap)方法
 static final int tableSizeFor(int cap) {
        //如果cap已经为2的幂,不进行-1操作的话得到的结果将为原先cap*2
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

tableSizeFor(int cap)方法用于找到最小的大于该容量的2的幂,保证容量为2的幂

假设cap=10
int n=cap-1=9;          9的二进制为1001
 n |= n >>> 1;
 -------------
 n>>>1      0100
 n          1001
 或运算      1101
 ----------------------
n |= n >>> 2;
n >>> 2     0011
n           1101
或运算       1111
------------------------------
n |= n >>> 4;
n >>> 4    0000
n          1111
或运算      1111
-------------------------------------
后面的操作 n |= n >>> 8; n |= n >>> 16;都不再会改变n的值
故最后的结果为n=1111+1=10000=16
 
 // //如果cap已经为2的幂,不进行-1操作的话得到的结果将为原先cap*2,我们来看不-1的情况
  假设cap=16
  int n=16;      16的二进制10000
   n |= n >>> 1;
 -------------
 n>>>1      01000
 n          10000
 或运算      11000
 ----------------------
n |= n >>> 2;
n >>> 2     00110
n           11000
或运算       11110
------------------------------
n |= n >>> 4;
n >>> 4    00001
n          11110
或运算      11111
-------------------------------------
n |= n >>> 8;   
n >>> 8   00000
n         11111 
或运算     11111
---------------------------------------------
后面的操作n |= n >>> 16;都不再会改变n的值
故最后的结果为n=11111+1=100000=32,最终得到的结果为正确结果的两倍         

接着看HashMap的最后一个构造方法

  //从另一个map构造当前Map
    public HashMap(Map<? extends K, ? extends V> m) {
         this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
    //真正向Map中添加另一个Map中元素的操作
     final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            //table==null即HashMap为null,第一次调用HashMap(Map<? extends K, ? extends V> m) 进行初始化
            if (table == null) { 
                //得到当前HashMap的容量
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                //如果当前容量大于了阈值,则设置新的阈值为大于t的最小的2的幂
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
        //如果被添加到新构造HashMap的旧map的元素多于阈值,进行扩容操作,扩容操作在后面讲解
            else if (s > threshold)
                resize();
            //遍历旧Map向新Map中添加元素
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                //putVal涉及到添加方法,将在下面介绍
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

put()方法

 //根据 key 的 hash 值来计算它的索引，使用这个索引来将这个键值对储存到对应的数组位置
//如果HashMap<K,V>中已经存在该键的值,则替换其值并返回替换前的值
   public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    } 
    // putVal方法,该方法并不允许用户使用
    //如果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为null,表示未进行初始化,调用resize扩容方法进行初始化
        if ((tab = table) == null || (n = tab.length) == 0)
        //下面有resize方法的详解
            n = (tab = resize()).length;
         //如果(n - 1) & hash这个位置没有Node
         //HashMap中通过(n - 1) & hash得到元素在桶中的位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //如果位置已经存在Node的情况
        else {
            Node<K,V> e; K k;
            //通过equal判断桶的第一个元素与要插入的元素是否为同一元素,是的话直接覆盖原先的值
            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) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果下一个节点e 不为null 并且这个节点与待插入节点相同,跳出循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                        //将p节点向后移动
                    p = e;
                }
            }
            //非尾部插入,发生元素值的替换
            if (e != null) { 
                V oldValue = e.value;
                //如果onlyIfAbsent为true的情况则不会发生元素值的替换
                if (!onlyIfAbsent|| oldValue == null)
                    e.value = value;
                    //空方法
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //修改记录map修改次数的变量
        ++modCount;
        //如果Map大小大于阈值进行扩容操作
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

初始化及扩容方法resize()

这里直接参考这篇博客,博主觉得这篇博客讲的十分清楚,思路十分清晰:点这里

//扩容方法,每次扩容会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是非常耗时的。在实际编程中，要尽量避免resize操作
final Node<K,V>[] resize() {
    //将当前map中的相关属性(包括Node<K,V>[] ,threshold以及原HashMap的长度)赋值给方法中的局部变量
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
     // 在HashMap<K,V>中已经存在元素的情况下的扩容
        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; 
        }
   	 //在HashMap<K,V>中不存在元素即第一次初始化
    //在调用有参数构造器初始化时会发生threshold!=0的情况,这时直接把旧阈值赋值给新的容量
        else if (oldThr > 0) 
            newCap = oldThr;
        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;
    //如果原先的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)
                        //通过e.hash & (newCap - 1)得到数组位置
                        newTab[e.hash & (newCap - 1)] = e;
                    //红黑树情况,此处不进行讨论
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { 
                        //定义两个链表为lo以及hi,loHead指向lo的头节点,loTail指向lo的尾结点,hiHead和hiTail类似
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        /**
                        主要结构:
                        do {
                            next = e.next;
                            }while ((e = next) != null);
                            依次遍历该存储桶位置上的链表中的节点.
                        */
                        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);
                        //如果lo链表非空, 我们就把整个lo链表放到新table的j位置上
					//如果hi链表非空, 我们就把整个hi链表放到新table的j+oldCap位置上
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

get()方法

根据key得到value,若不存在该key,则返回null,因为允许键和值为null,故返回null并不一定表名HashMap中不存在该键
public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    //getNode(int hash, Object key)方法,同putVal()一样,不允许用户使用
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //这么多判断条件总之就是该HashMap不为空并且(n - 1) & hash位置存在元素
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
           //如果该(n - 1) & hash第一个元素就是要查找的元素,直接返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
            //红黑树情况
                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);
            }
        }
        //返回null
        return null;
    }

问1:HashMap如何保证键的唯一性

//通过这一步判断如果该键对应的table位置不存在元素(也就是说不存在该键),直接插入该键值对
if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
//当通过判断断定该键值对已经存在时,在后面替换旧值
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
       Node<K,V> e = p;

参考文章:

• https://blog.csdn.net/fan2012huan/article/details/51097331
• https://segmentfault.com/a/1190000015812438