HashMap细节及Map实践

结构

从结构实现来说，HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的

下面简述一下hashmap的属性和重要方法put(k,v)和resize()：

属性

• 默认初始容量为16
• 默认负载因子为0.75
• 桶中链表节点转化为红黑树节点的桶元素个数阈值为8
• 桶中红黑树节点转化为链表节点的桶元素个数阈值为6
• 链表节点转化为红黑树节点的最小元素个数为64，即如果桶内元素已经达到转化红黑树阈值，但是表元素总数未达到阈值，则值进行扩容，不进行树形化

//默认初始容量为16，容量必须为2的幂，这个容量指的是数组的长度
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表节点转化为红黑树节点的阈值为8
static final int TREEIFY_THRESHOLD = 8;
//红黑树节点转化为链表节点的阈值为6
static final int UNTREEIFY_THRESHOLD = 6;
//链表节点转化为红黑树节点的最小元素个数为64
static final int MIN_TREEIFY_CAPACITY = 64;
//下一个调整大小的值（容量*加载因子）
int threshold;
//负载因子
final float loadFactor;

put(K key, V value)

主体流程

• 计算得到hash值，进而得到桶的位置
• 如果桶没节点，就直接新建一个节点放入
• 否则，如果桶内节点的key是要放入的key，就直接更新
• 继续判断，如果节点类型是红黑树，那么进行放入红黑树操作
• 否则，放入链表：对链表从前往后遍历，如果节点的key等于目标key，就更新value；如果没匹配上，就新建节点放到链表末尾。并且判断节点数量>=8，就转红黑树
• 如果节点有新增，判断如果节点数量大于最大容量（node数组大小×负载因子），则扩容

链表转化红黑树：
1)先判断如果node数组为空或者长度<最小红黑树转换长度64，则扩容
2)否则，将node转换为treenode链表,再对treenode链表进行红黑树转化

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, 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;
        if ((tab = table) == null || (n = tab.length) == 0)
          	//延迟初始化，put元素时才建数组
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
          	//桶内没节点，直接新建节点放入
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
              	//如果桶内节点的key是目标key，就直接更新
                e = p;
            else if (p instanceof TreeNode)
              	//如果桶内节点是红黑树，执行放入红黑树逻辑
              	
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
              	//否则，执行放入链表逻辑
                for (int binCount = 0; ; ++binCount) {
                  /*对链表从前往后遍历，如果节点的key等于目标key，就更新value
                  如果遍历完都没匹配上，就新建节点放到链表末尾。如果桶内节点数量>=8，就转红黑树 */
                    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;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                      //匹配上，后续会更新节点的value
                        break;
                    p = e;
                }
            }
          	//如果put操作是更新而不是新增，更新节点的value，并返回旧值oldValue
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                  //链表和树的value更新在这
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
          //新增，则如果元素个数 > 容量*负载因子，就扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

Node<K,V>[] resize()

链表节点转移
e.hash & oldCap 以a节点为例，就是100(a.hash)&100(数组长度)，也就是第三位

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;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
              //一般情况，扩容后新容量=旧容量✖️2
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
          	//代表数组没初始化，但是指定了初始化容量
          	//比如 Map<String,String> map = new HashMap<>(16)
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
          	//oldThr=0，默认的数组初始化的逻辑,新容量大小设置为16，新扩容阈值=16*0.75
          	//比如 Map<String,String> map = new HashMap<>()
            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;
        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)
                      	//如果桶节点的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;
                          	//如果e的参与索引计算的前一位是0
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                            //e的参与索引计算的前一位是1
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                      	//把lo链表转移到新数组的原位置
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                      	//把hi链表转移到新数组的 原位置+旧数组长度
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
              //树的转移与链表逻辑一样，也是拆分成两个链表
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                if (lc <= UNTREEIFY_THRESHOLD)
                  //如果子链表节点个数<=6，红黑树转链表
                    tab[index] = loHead.untreeify(map);
                else {
                  //子节点个数>6
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                      	//另一个子链表不为空，说明红黑树排序被打乱，就重新转红黑树
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }

实现细节

问题1:多线程情况下会出现环吗？

我们可能有听到过这样的一种说法，hashmap在多线程的情况下会出现环，这个是什么情况呢
其实在jdk1.7的版本才会出现环，主要代码部分如下

//jdk1.7的扩容 部分代码

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
          //一、遍历桶中的元素
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
              	//二、计算元素在新数组的位置
                e.next = newTable[i];//①e元素指向新数组的桶节点
                newTable[i] = e;//②e元素放入桶数组
                e = next;//③处理e元素指向next
            }
        }
    }

这个是hashMap扩容时元素从旧数组重hash到新数组的代码，元素的转移用的是所谓的“头插法”，主要逻辑：
1)迭代数组中的桶元素
2)计算桶元素在新数组的位置
3)转移桶节点的所有元素

• 指针e指向数组的桶节点
• e放入新的桶数组
• 让e指向next指针指向的元素

因为元素转移到新链表时是作为头节点插入的，因此称为“头插法”

多线程情况下，假设有两个线程T1、T2同时扩容，T1线程执行①语句之前时挂起，此时T1线程里e=a，next=b

T2线程正常执行完毕，此时b->a->null
T1线程接着往下执行,此时T1线程内的情况如上图
T1从①语句开始执行，后续执行流程如下

出现了环有什么问题呢？下一次执行了put(k,v)方法，key刚好索引到了有环的这个桶并且key和a、b都不相等，它就会从链表头节点向后遍历，造成死循环
在jdk1.8中做了优化，不再采用头插法方式，而是直接插入链表尾部，所以jdk1.8是不会出现环形链表的情况

问题2:key的hash是怎么计算的？

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

//计算桶位置
i = (n - 1) & hash

求key的hash代码很短，主要逻辑
如果key为null就返回0，这说明hashMap的key是可以为null的,这是它与hashTable的一个不同点；key不为null，是hashcode和它的无符号右移16位的值做异或，也就是hashcode的低16位和它的高16位做异或
在获取桶的位置的时候，会与(数组长度-1)做与运算，而数组长度一般都小于2^16，所以，如果不进行该操作，那么就总是hashcode的低16位参与运算，如果数组长度更低，那么参与运算的位数也更低。为了让hash的结果更加散列减小hash碰撞，因此将hashcode的高16位和低16位做异或运算，得到的hash值，再与数组长度-1做与运算，来求在数组的位置

问题3:Object的hashcode是对象的内存地址吗？

hashCode对于哈希碰撞的产生是有极大影响。那么有一个问题，一个对象它的hashCode是它的的内存地址吗？应该很多人听过对象的hashcode默认返回的是对象的内存地址。在jdk1.8中有如下对于hashCode方法的描述：在合理可行的情况下，不同的对象的hashCode返回不同的整数。典型的实现是把对象的内存地址转换成整数，但是java不提供这种技术的实现。

    /* As much as is reasonably practical, the hashCode method defined by
     * class {@code Object} does return distinct integers for distinct
     * objects. (This is typically implemented by converting the internal
     * address of the object into an integer, but this implementation
     * technique is not required by the
     * Java™ programming language.、
     */
     public native int hashCode();

结论：hashCode方法的返回值与对象的地址值不是一回事。
使用对象的地址值作为它的hashCode返回值只是其众多生成策略之一。生成策略与jvm启动参数有关。例如可以通过-XX:hashCode=4来指定hashcode的生成策略为返回对象的内存地址

1. hashCode == 0
此类方案返回一个Park-Miller伪随机数生成器生成的随机数
OpenJdk 6 &7的默认实现
2.hashCode == 1
此类方案将对象的内存地址，做移位运算后与一个随机数进行异或得到结果
3.hashCode == 2
此类方案返回固定的1
4.hashCode == 3
此类方案返回一个自增序列的当前值
5.hashCode == 4
此类方案返回当前对象的内存地址
6.其他(JDK8默认)
返回由当前线程有关的一个随机数和三个确定值，经Marsaglia’s xorshift scheme随机数算法得到的一个随机数

验证代码

启动参数 -XX:hashCode=4

启动参数 -XX:hashCode=2

在OpenJDK6、7中使用的是随机数生成器的（第一种-XX:hashCode=0）方式，OpenJDK8、9则采用第六种作为默认的生成方式。所以，单纯从OpenJDK的实现来说，其实hashcode的生成与对象内存地址没有什么关系。而Object类中hashCode方法上的注释，很有可能是早期版本中使用到了第5种方式(-XX:hashCode=4)，也就是用内存地址返回hashcode

问题4:Object的hashcode默认算法是随机数生成的，那么多次调用对象的hashcode()方法返回的值怎么是保持不变的？

map的最佳实践

hashMap初始化

一个建议是，如果你知道你要存储的容量设为n，那么初始化hashMap时可以这样定义：

Map mapBest = new HashMap((int) ((float) n / 0.75F + 1.0F));

也可以使用guava工具类里的方法，它的内部也是使用上面的算法来初始化的

Map mapBest  = Maps.newHashMapWithExpectedSize(n)

通过这种方式避免扩容，提高性能

ImmutableMap

场景：集合初始化之后，不希望修改集合或希望集合保持不变时,比如系统初始化一些配置后不希望配置被修改的场景，就可以用不可变集合

怎么理解不可变集合呢？就是说集合一旦初始化，就不允许改变。它们是不提供修改集合元素的方法。比如ImmutableMap调用put(k,v)方法，会直接抛异常UnsupportedOperationException

不可变对象有很多优点，包括：

• 线程安全：可以被许多线程使用而没有竞争条件的风险。
• 不需要支持突变，并且可以通过该假设节省时间和空间。所有不可变集合的实现都比它们的可变兄弟更节省内存。（分析）
• 可以用作常数，并期望它保持固定

ImmutableMap可以理解成是只支持查询操作的hashMap
//
ImmutableMap<String, String> immutableMap = ImmutableMap.of("firstKey", "firstValue", "secondKey", "secondValue");
ImmutableMap<String, String> immutableMap2 = ImmutableMap.<String,String>builder().put("k1", "k2").build();

EnumMap

场景：当key的范围固定并且有限时，可以使用EnumMap，极大提升性能

特点：key是枚举类型
它在内部是用数组存储value,数组长度就是枚举总个数，并且根据枚举类型的key能直接定位到内部数组的索引。不需要计算hashCode()，效率非常的高

EnumMap<ColorEnum,String> enumMap=new EnumMap<ColorEnum, String>(ColorEnum.class);
enumMap.put(ColorEnum.BLACK,"black");
enumMap.put(ColorEnum.RED,"red");
String s = enumMap.get(ColorEnum.BLACK);//s=black

public enum ColorEnum {
    BLACK,WHITE,RED;
}

Multimap

场景：大部分有经验的同学应该都实现过一对多的映射的场景， 像这样Map<K, List>or Map<K, Set>。如果用一般写法，繁琐且易出错

a -> 1						
a -> 2
a -> 4
b -> 3
c -> 5 
也即是
a -> [1, 2, 4]
b -> [3]
c -> [5]

一般写法的put，以Map<K, List>为例，

Map<String,List<String>> map=new HashMap<>();
    List<String> strings = map.get(key);
    if (null==strings){
        strings=new ArrayList<>();
    }
    strings.add(value);
    map.put(key,strings);

Guava 的Multimap框架可以轻松处理这种从键到多个值的映射
Multimap是一个接口，通常我们可能使用的是这两个子接口 ListMultimap、SetMultimap。例如

// creates a ListMultimap with tree keys and array list values
//TreeMap+ArrayList
ListMultimap<String, Integer> treeListMultimap =
    MultimapBuilder.treeKeys().arrayListValues().build();
				treeListMultimap.put("a","1");
        treeListMultimap.put("a","2");
        treeListMultimap.put("a","4");

// creates a SetMultimap with hash keys and enum set values
//HashMap+RegularEnumSet
SetMultimap<Integer, MyEnum> hashEnumMultimap =
    MultimapBuilder.hashKeys().enumSetValues(MyEnum.class).build();

上面的是两个自定义的MultiMap。实际上，Multimap提供了很多种实现类.，都是一对多的类

案例：

HashMultimap初始化时key的size过大导致oom
	//hashMap+hashSet结构 <dagKey,Set<sourceDag>>
	HashMultimap<String, String> localBlockMap = initializeBlockMap(dagInfoList)
  dagInfoList.forEach(jobInfo -> {
            List<String> sourceDagList = jobInfo.getSourceDags();
            sourceDagList.forEach(sourceDag ->
                    localBlockMap.put(generateKey(jobInfo.getClusterId(), jobInfo.getDagId(),
                        jobInfo.getExecutionDate()), sourceDag)
            );
        });

private HashMultimap<String, String> initializeBlockMap(List<DagInfo> dagInfoList) {
        int dagCount = 0;
        for (DagInfo jobInfo : dagInfoList) {
            dagCount += jobInfo.getSourceDags().size();
        }
  			//第一个参数是key（hashMap）的初始化容量，第二个参数是value（hashSet）的初始化容量
        return HashMultimap.create(dagCount, dagInfoList.size());
    }

dagInfoList

• sourceDagList
  • dagKey (k)
  • sourceDag (v)
    sourceDag是有大量重复的，导致计算dagCount时数量膨胀了

BiMap

场景：有时候会遇到双向映射的场景，如果想将值映射到键，通常的做法是建立两个map，让这两个map保持同步，例如

Map<String, Integer> map1 = Maps.newHashMap();
Map<Integer, String> map2 = Maps.newHashMap();

map1.put("one",1);
map2.put(1, "one");

BiMap可以很方便的实现上面功能。
● 可以查看value到key的映射
● 可以校验value的唯一性,当value不唯一时会抛出异常

BiMap<String, Integer> userId = HashBiMap.create();
        userId.put("1",1);
        userId.put("2",2);
        Integer v1 = userId.get("2");//v1=2
        BiMap<Integer, String> inverse = userId.inverse();//得到value到key的map
        String v2 = inverse.get(2);//v2="2"

它的内部既保存了key->value的映射，也保存了value->key的映射，大致原理为

BitMap是一个接口，它的常见实现有

参考：
论对象的地址值与hashCode返回值（对象hash值）之间的关系
GC时对象地址变了，hashCode如何保持不变
ImmutableCollections
Multimap