一、基础篇--1.2Java集合-HashMap源码解析

https://www.cnblogs.com/chengxiao/p/6059914.html

散列表

哈希表是根据关键码值而直接进行访问的数据结构。也就是说，它能通过把关键码值映射到表中的一个位置来访问。这个映射函数就叫做散列函数，存放记录的数组就叫散列表。

给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)。

哈希冲突

如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。

HashMap实现原理

HashMap的数据结构

HashMap的主干是一个Entry数组，Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对还有下一个节点，因此Entry是一个单向链表。代码如下：

static class Entry implements Map.Entry {
        final K key;
        V value;
        Entry next;
        int hash;
        Entry(int h, K k, V v, Entry n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
        public final K getKey() {
            return key;
        }
        public final V getValue() {
            return value;
        }
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }
        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }
        public final String toString() {
            return getKey() + "=" + getValue();
        }
        void recordAccess(HashMap m) {
        }
        void recordRemoval(HashMap m) {
        }
    }

HashMap的整体结构如下图：

可以看出，HashMap是有数组和链表组成的，数组是HashMap的主体，链表是为了解决哈希冲突而存在的。由上面结构可以看出来，如果不存在链表，HashMap的查询修改删除性能都非常好，如果存在链表很多，即存在很多哈希冲突，则性能会降低很多，因为到指定位置后还要遍历整个链表。

HashMap源码分析

HashMap的继承关系

HashMap继承于AbstractMap，实现了Map<K,V>

java.lang.Object
   ↳     java.util.AbstractMap
         ↳     java.util.HashMap
public class HashMap
    extends AbstractMap
    implements Map, Cloneable, Serializable { }

HashMap的关键属性

源码如下：

    // 默认的初始容量是16，必须是2的幂。
    static final int DEFAULT_INITIAL_CAPACITY = 16;
    // 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    / 存储数据的Entry数组，长度是2的幂。
    // HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表
    transient Entry[] table;
    // HashMap的大小，它是HashMap保存的键值对的数量
    transient int size;
    // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）
    int threshold;
    // 加载因子实际大小
    final float loadFactor;
    // HashMap被改变的次数，fail-fast用于快速抛出异常ConcurrentModificationException
    transient int modCount;
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

HashMap的重要方法解析

HashMap()

HashMap有4个构造器，其他构造器如果用户没有传入initialCapacity 和loadFactor这两个参数，会使用默认值

initialCapacity默认为16，loadFactory默认为0.75，关键的一个代码如下：

 public HashMap(int initialCapacity, float loadFactor) {
         //对传入的初始容量、加载因子进行校验，初始容量不能小于0，最大只能是1<<30(2³°)
        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);
        // Find a power of 2 >= initialCapacity
        // 找到一个最接近初始容量的是2的倍数的容量值
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        this.loadFactor = loadFactor;
        //根绝容量和加载因子算扩容的阀值
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //初始化一个空的Entry的数组
        table = new Entry[capacity];
        //是否使用备用Hash算法，默认不开启
        //Holder.ALTERNATIVE_HASHING_THRESHOLD 不配置的话默认是最大值
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        //空方法
        init();
    }

put()

初始化后，看下如何添加值的，看put()的源码，如下

public V put(K key, V value) {
        //null值的话单独处理，null值放在数组table[0]的位置，后面会讲到
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值，比较重要后面单独列出来
        int hash = hash(key);
        //获取在table中的实际位置
        int i = indexFor(hash, table.length);
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            //如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);//空的方法
                return oldValue;
            }
        }
        //保证并发访问时，若HashMap内部结构发生变化，快速响应失败
        modCount++;
        //新增一个Entry
        addEntry(hash, key, value, i);
        return null;
    }

putForNullKey()

 private V putForNullKey(V value) {
         //key为NULL时，默认放在table[0]的位置，或者table[0]的冲突链上，其他操作同上面put();
        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++;
        addEntry(0, null, value, 0);
        return null;
    }

hash()

final int hash(Object k) {
        int h = 0;
        //如果使用备用hash算法，String类型会单独采用stringHash32，并且使用hashSeed，默认hashSeed==0
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }
        //用了很多的异或，移位等运算，对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
        h ^= k.hashCode();
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

indexFor()

//返回数组的下标，采用位运算不用取模，对于计算机位运算效率更高
static int indexFor(int h, int length) {
        return h & (length-1);
    }

addEntry()

void addEntry(int hash, K key, V value, int bucketIndex) {
        ////当size超过临界阈值threshold，并且即将发生哈希冲突时进行扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容方法，下面会单独列出来
            resize(2 * table.length);
            //计算下标和hash值
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        //创建Entry，单独列出来
        createEntry(hash, key, value, bucketIndex);
    }

resize()

扩容方法，比较重要，可以解释为什么数组长度一定是2的次幂，代码如下：

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];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        //计算是否需要重新计算Hash值
        boolean rehash = oldAltHashing ^ useAltHashing;
        //赋值给新的数组，下面会单独列出来
        transfer(newTable, rehash);
        table = newTable;
        //计算新的阀值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

transfer()

    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        //for循环中的代码，逐个遍历链表，重新计算索引位置，将老数组数据复制到新数组中去
        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);
                //将当前entry的next链指向新的索引位置,newTable[i]有可能为空，有可能也是个entry链，如果是entry链，直接在链表头部插入。
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

这个方法将老数组中的数据逐个链表地遍历，扔到新的扩容后的数组中，我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后，再通过和 length-1进行位运算得到最终数组索引位置。

1.hashMap的数组长度一定保持2的次幂，比如16的二进制表示为 10000，那么length-1就是15，二进制为01111，同理扩容后的数组长度为32，二进制表示为100000，length-1为31，二进制表示为011111。从下图可以我们也能看到这样会保证低位全为1，而扩容后只有一位差异，也就是多出了最左位的1，这样在通过 h&(length-1)的时候，只要h对应的最左边的那一个差异位为0，就能保证得到的新的数组索引和老数组索引一致(大大减少了之前已经散列良好的老数组的数据位置重新调换)。

2.数组长度保持2的次幂，length-1的低位都为1，会使得获得的数组索引index更加均匀，比如：

我们看到，上面的&运算，高位是不会对结果产生影响的（hash函数采用各种位运算可能也是为了使得低位更加散列），我们只关注低位bit，如果低位全部为1，那么对于h低位部分来说，任何一位的变化都会对结果产生影响，也就是说，要得到index=21这个存储位置，h的低位只有这一种组合。这也是数组长度设计为必须为2的次幂的原因。

!

如果不是2的次幂，也就是低位不是全为1此时，要使得index=21，h的低位部分不再具有唯一性了，哈希冲突的几率会变的更大，同时，index对应的这个bit位无论如何不会等于1了，而对应的那些数组位置也就被白白浪费了。

createEntry()

这个方法比较简单没什么东西，就是简单创建个Entry，赋值到数组中

void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

get()

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry entry = getEntry(key);
        return null == entry ? null : entry.getValue();
    }
  private V getForNullKey() {
        //key为NULL时，存在table[0]位置
        for (Entry e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }
 final Entry getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

可以看出，get方法的实现相对简单，key(hashcode)-->hash-->indexFor-->最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表，通过key的equals方法比对查找对应的记录。要注意的是，有人觉得上面在定位到数组位置之后然后遍历链表的时候，e.hash == hash这个判断没必要，仅通过equals判断就可以。其实不然，试想一下，如果传入的key对象重写了equals方法却没有重写hashCode，而恰巧此对象定位到这个数组位置，如果仅仅用equals判断可能是相等的，但其hashCode和当前对象不一致，这种情况，根据Object的hashCode的约定，不能返回当前对象，而应该返回null，后面的例子会做出进一步解释。

关于HashMap的源码分析就介绍到这儿了，最后我们再聊聊老生常谈的一个问题，各种资料上都会提到，“重写equals时也要同时覆盖hashcode”，我们举个小例子来看看，如果重写了equals而不重写hashcode会发生什么样的问题

public class Demo {
    private String name;
    private int idCde;
    public Demo(String name, int idCde) {
        this.name = name;
        this.idCde = idCde;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getIdCde() {
        return idCde;
    }
    public void setIdCde(int idCde) {
        this.idCde = idCde;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Demo demo = (Demo) o;
        return idCde == demo.idCde &&
                Objects.equals(name, demo.name);
    }
//    @Override
//    public int hashCode() {
//
//        return Objects.hash(name, idCde);
//    }
    public static void main(String[] args) {
        HashMap map = new HashMap();
        Demo demo = new Demo("张三",123456789);
        map.put(demo,"测试");
        System.out.println("结果:"+map.get(demo));
        System.out.println("结果:"+map.get(new Demo("张三",123456789)));
    }
}

输出结果为：

结果:测试
结果:null

尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)-->hash-->indexFor-->最终索引位置 ，而通过key取出value的时候 key(hashcode1)-->hash-->indexFor-->最终索引位置，由于hashcode1不等于hashcode2，导致没有定位到一个数组位置而返回逻辑上错误的值null（也有可能碰巧定位到一个数组位置，但是也会判断其entry的hash值是否相等，上面get方法中有提到。）

　　所以，在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。