关于HashMap

关于HashMap源码的文章网上已经有很多的博客了，其中的关键点：
1，HashMap底层实际是一个数组，数组中存放的元素是链表（jdk1.8以前）或者红黑树（jdk1.8中链表长度超过8时）；
2，这个数组在HashMap中的属性名定义为table，其初始长度为16；
3，数组中的每一个元素为链表（或红黑树）或者null，jdk1.8以后，如果链表长度超过8，会转换为红黑树；
4，当map中的元素大于table的长度*0.75（这个是定义好的一个扩容参数）时，table的长度将扩大两倍，源码中是将这个值向左移一位；
5，当将一个新的值放入map中时，会根据这个值的hash来决定放在table中的位置，即其hash值决定其在table中的索引index，具体算法为

int hash = obj.hashCode ^ obj.hashCode >>> 16;
int index = hash & (table.length - 1);

；
5，进行扩容时（调用resize()方法），table的长度会增加一倍，此时需要将旧的table中的值复制到新table中去，复制过去之后会重新根据hash来计算其在新table中的索引位置，所以table中的链表结构会发生变化，这样是为了防止一个链表越来越长，让map中的元素在table中尽量分布均匀。

下面结合反射来看看一个HashMap内部的结构：

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class Test {
    public static void main(String[] args) throws Exception {
        HashMap<String, String> map = new HashMap<>();
        for (int i = 1; i <= 99; i++) {
            map.put(i + "", i + "");
        }
        Class hashMap = map.getClass();
        Field table = hashMap.getDeclaredField("table");
        table.setAccessible(true);//非public属性必须设置访问权限为true
        Object tables = table.get(map);
        int tableLength = Array.getLength(tables);//table是一个数组，其类型为HashMap的非public内部类，只能这样去获取其数组长度

        int count = 0;//统计table内非空元素的数量
        Map<Integer, Integer> data = new TreeMap<>();//统计table内每个链表的长度,其中key为table索引，value为对应索引位置的链表长度
        for (int i = 0; i < tableLength; i++) {//遍历所有的table元素
            Object obj = Array.get(tables, i);
            if (obj != null) {
                count++;
            }

            int length = 0;//统计当前链表的长度
            while (obj != null) {
                Class node = obj.getClass();
                Field next = node.getDeclaredField("next");
                next.setAccessible(true);
                obj = next.get(obj);
                length++;
            }
            if (length > 0) {
                data.put(i, length);
            }
        }

        System.out.println("map size:" + map.size());
        System.out.println("table length:" + tableLength);
        System.out.println("linkedList count:" + count);
        System.out.println("linkedList max-length:" + Collections.max(data.values()));
        System.out.println("linkedList index-length:" + data);
    }
}

以上代码的输出结果如下：

map size:99
table length:256
linkedList count:97
linkedList max-length:2
linkedList index-length:{0=1, 1=1, 23=1, 24=1, 25=1, 26=1, 27=1, 28=1, 29=1...}

从结果中我们可以看到，map中有99个元素，内置数组table的长度扩容到了256，但是其中只有97个位置是有链表的，其他位置均为null；所有链表中长度最长的只有2，从最后一行输出信息可以看到table各个索引位置链上表的长度，如果还想看链表上每个节点的值，也可以自行打印出来。

拓展思考：

当HashMap使用String作为key值时，由于String的hashcode计算方式比较简单，为

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]。

当HashMap中存放的元素比较多且有大量元素计算得到的hashcode相同时，hash冲突比较严重，在即table内有些链表的长度很长，此时查找效率会大幅度降低，尽管在java8以后链表长度超过8会转换为红黑树，但是从上面的例子中我们可以看到，table的长度有256，但是只有97个位置是存放了元素的，其他位置都是null，这说明数组有超过一半的位置没有用来存放map的元素，利用率很低，这也是因为String的hashcode算法散列得不够稀疏所致，如果可以使用更合理的hashcode算法，这种场景下hashMap的性能在理论上可以得到提升。

其他的hash算法可以参考：murmur2/MurmurHash2.c at master · abrandoned/murmur2 · GitHub

参考其hash算法重写String的hashCode函数如下：

@Override
    public int hashCode() {
        int h = this.hashCode();
        if (h == 0 && this.value.length > 0) {
            int m = 0x5bd1e995;
            int r = 24;
            int seed = 0x36589423;//这是自定义的一个值
            h = seed ^ this.value.length;
            for (int i = 0; i < this.value.length; i++) {
                int k = (int) this.value[i];
                k *= m;
                k ^= m >> r;
                k *= m;

                h *= m;
                h ^= k;
            }
            h = h < 0 ? -h : h;//这里可能会溢出，暂未做处理
            this.hash = h;
        }
        return h;
    }

在github上搜索murmur2即可，也可以寻找其他的hash算法。