java集合-HashMap源码详解（基于JDK1.7版本）

目录

 

一、概述

二、HashMap源码解读（JDK1.7）

1，构造函数：

1.1 默认的构造函数：

1.2 一个参数的构造函数HashMap(int initialCapacity)

1.3 两个参数的构造函数HashMap(int initialCapacity, float loadFactor)

2，HashMap的数据结构

3，put方法

3.1 根据key的hashCode计算出一个更为分散的hash值

3.2 根据hash值计算出该元素在数组中的角标indexFor(hash, table.length)方法：

3.3  添加一个新的entiy

4，扩容方法

5，扩容后数据的转移

6，get方法

7，对key为null的特殊处理

7.1 put key为null的数据

7.2 get key为null的数据

三、HashTable

四、小结

---

一、概述

HashMap底层的数据结构为一个entry数组，entry对象中有下一个entry对象的next引用形成单向链表。

根据键的hashCode值来确定数组下标位置，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null，允许多条记录的值为null。HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。

二、HashMap源码解读（JDK1.7）

1，构造函数：

共有三个构造函数：

HashMap():默认的构造函数，初始容量是16，加载因子为0.75

HashMap(int initialCapacity)：可以自己设置初始容量，但是会被重置为一个大于等于该值的2的幂次数

HashMap(int initialCapacity, float loadFactor)：可以自己设置初始容量和加载因子。

1.1 默认的构造函数：

//在构造函数中未指定时使用的加载因子。
static final float DEFAULT_LOAD_FACTOR = 0.75f;

//默认初始容量-必须是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;

public HashMap() {
        // 使用默认的加载因子
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        // 阈值为初始容量*加载因子 等于12
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        // 创建一个新的Entry数组，大小为默认值16
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        // 这里初始化方法为空，并没有用到。
        init();
    }

1.2 一个参数的构造函数HashMap(int initialCapacity)

它其他是调用了两个参数的构造函数，那我们就去看两个参数的构造函数

public HashMap(int initialCapacity) {
        // 调用了两个参数的构造函数
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

1.3 两个参数的构造函数HashMap(int initialCapacity, float loadFactor)

初始容量不能小于0，加载因子不能小于等于0

指定的初始容量如果不是2的幂次数，则重置为一个大于等于它的2的幂次数

    //最大容量。不超过2的30次幂
    static final int MAXIMUM_CAPACITY = 1 << 30;

public HashMap(int initialCapacity, float loadFactor) {
        // 如果初始值小于0则抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        // 如果指定的初始值大于2的30次幂，则设置为2的30次幂
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 如果加载因子小于等于0或者为null，则抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

        // 找到一个大于等于指定初始容量的的2的幂次方的数
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        // 初始化加载因子
        this.loadFactor = loadFactor;
        // 初始化阈值
        threshold = (int)(capacity * loadFactor);
        // 初始化数组
        table = new Entry[capacity];
        // 空方法
        init();
    }

2，HashMap的数据结构

从构造方法中可以看出，HashMap的底层结构是一个数组，类型的Entry。

下面看一下Entry的结构：

记录了key、value、hash值和指向下一个entry的引用（单向链表结构）

所以HashMap的底层结构是使用数组加链表来实现的

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;// 就是HashMap的key值
        V value;// HashMap的value值
        Entry<K,V> next;// 指向下一个entiry元素的引用
        final int hash;// 通过key计算出来的hash值

        // 设置4个属性的构造函数
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
        // 获取key
        public final K getKey() {
            return key;
        }
        // 获取value
        public final V getValue() {
            return value;
        }
        // 设置value值：使用新的值替换老的值并返回老的值
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        // 只有但key和value的值都相等时才返回true
        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;
        }

        // 使用key的hashCode 异或 value的hashCode 得出整个节点的hashCode
        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<K,V> m) {}

        
        void recordRemoval(HashMap<K,V> m) {}
    }

3，put方法

根据key的hashCode计算出一个新的hash值，然后根据hash值计算出这个key应该在数组哪个角标位置

通过一个for循环来判断key是否重复：如果key重复，则覆盖value，然后return老得value值。

如果key不重复，则在数组i的位置放入一个entry对象：先取出i位置原来的entry对象，然后把新的entry对象放入该位置，新entry的next指向了原来的entry对象（头插法），形成链表。

public V put(K key, V value) {
        if (key == null)// 如果是null值则特殊处理
            return putForNullKey(value);
        // 根据key的hashCode计算出一个更为分散的hash值
        int hash = hash(key.hashCode());
        // 根据hash值计算出该元素在数组中的角标
        int i = indexFor(hash, table.length);
        // 循环条件为取出角标为i的entry，如果不为空才会进入循环
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 比较新老kye的hash值是否相同，新老key的值是否相同，如果都满足：
            // 则把这个entry的value值替换为新值，然后return老的value值
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);// 在HashMap中这是一个空方法。
                return oldValue;
            }
        }
        // 如果key没有重复，则把计数器+1
        modCount++;
        // 添加一个新的entiy（其实就是对数组角标i位置赋值一个entry，然后判断是否需要扩容）
        addEntry(hash, key, value, i);
        return null;
    }

3.1 根据key的hashCode计算出一个更为分散的hash值

hash(key.hashCode())方法：

    static int hash(int h) {
        // 将hash值的高位与低位数进行异或运行
        // 从而是的hash值的高位数的不同能影响的低位的数值
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

3.2 根据hash值计算出该元素在数组中的角标
indexFor(hash, table.length)方法：

static int indexFor(int h, int length) {
        return h & (length-1);
    }

length的值为2的幂次数，2的幂次数的二进制表示为高位为1，低位数都是0.

比如说32的二进制数：0000 0000 0000 0000 0000 0000 0010 0000

length-1之后就变为：0000 0000 0000 0000 0000 0000 0001 1111

h为处理之后的hash值，比如为0001 0111 0001 0010 1001 0011 1101 0110

当h和length-1进行与操作之后，由于length的高位数都为0，并且最大值为数组的最大角标，所以结果会得到一个不大于length-1的数，用于作为数组的角标。

3.3  添加一个新的entiy

addEntry(hash, key, value, i)方法：

数组bucketIndex角标下的entry取出赋值给e

新建一个entiy对象，并把next指向老得entry对象， 对数组bucketIndex角标位置进行重新赋值

把计数器+1，然后判断当前的entiy元素个数是否大于等于阈值，如果是则需要扩容

扩容规则为：老容量*2，即为老容量的两倍

    void addEntry(int hash, K key, V value, int bucketIndex) {
        // 数组bucketIndex角标下的entry取出赋值给e
        Entry<K,V> e = table[bucketIndex];
        // 新建一个entiy对象，并把next指向老得entry对象
        // 对数组bucketIndex角标位置进行重新赋值
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 把计数器+1
        // 判断如果当前的entiy元素个数大于等于阈值，则需要扩容
        if (size++ >= threshold)
            resize(2 * table.length);
    }

4，扩容方法

获取扩容前的数组的长度

如果老数组的长度已经是容量的最大值，则把阈值置为int的最大值，然后跳出方法，不再进行扩容

创建一个新的数组并将老的数据转移到新的数组中，然后重复赋值给HashMap的数组引用

重新计算阈值

void resize(int newCapacity) {
    // 获取扩容前的数组的长度
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    // 如果老数组的长度已经是容量的最大值，则把阈值置为int的最大值，然后跳出方法，不再进行扩容
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    // 创建一个新的数组
    Entry[] newTable = new Entry[newCapacity];
    // 将老的数据转移到新的数组中
    transfer(newTable);
    // 将新数据赋值给HashMap的数组引用
    table = newTable;
    // 重新计算阈值
    threshold = (int)(newCapacity * loadFactor);
}

5，扩容后数据的转移

transfer(Entry[] newTable)方法：

遍厉老得数据，根据新容量计算出元素的新角标

将老数组的entry放到新数组中，但是由于entry的hash值不同，所以同一个链表中的entry元素方法新数组中并不一定放到同一个角标下。

因为扩容方式为*2的方式，所以新角标只存在两种可能：1，不变（oldIndex）；2，老数组长度+老的角标（oldTable.length+oldIndex））

所以需要把链表的entry对象依次取出计算新的角标，并把取出的老的entry对象的next引用指向新角标上的entry对象（如果为null则指向null）

void transfer(Entry[] newTable) {
        Entry[] src = table; // src为老的数据
        int newCapacity = newTable.length;
        // 遍厉老的数组数据
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];// 将entry元素取出放到临时变量中
            if (e != null) {
                // 如果该角标下的entry不为空，则把它置为null
                src[j] = null;
                do {
                    // 取出该entry的下一个entry对象，临时存储为next
                    Entry<K,V> next = e.next;
                    // 重新计算角标值
                    int i = indexFor(e.hash, newCapacity);
                    // 把当前entry的next引用指向新数组的i角标
                    e.next = newTable[i];
                    // 将新数组i角标赋值为e
                    newTable[i] = e;
                    // 把值设置为e的next指向的entry
                    e = next;
                    // 如果next指向不为空，则继续取出元素进行转移
                } while (e != null);
            }
        }
    }

关于扩容时候产生的死循环，这个问题是由于多线程同时进行put操作时，刚好又要进行扩容，然后在扩容数据转移的时候造成的。本来HashMap的设计就不是线程安全的，不让多线程同时访问。

在并发操作的情况下可能会产生循环链表结构，然后在put或者get到当前角标的数据的时候就会出发死循环；不仅如此，在并发扩容转移数据的时候还有可能造成数据丢失的问题。

6，get方法

根据key计算出角标，遍厉该角标下的entry链表

如果key的值相同则说明找到

如果没有找到则返回null

所以：如果get一个不存在的值，HashMap是不会报错的，而是会返回null

public V get(Object key) {
        // 如果key为null，做特殊处理
        if (key == null)
            return getForNullKey();
        // 计算出key的hash
        int hash = hash(key.hashCode());
        // 遍厉hash对应角标下的entry链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            // 如果hash值、key值都相同，则说明找到了这个entry，返回该entry的value即可
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        // 如果遍厉之后没有找到则返回null
        return null;
    }

7，对key为null的特殊处理

7.1 put key为null的数据

从源码可以看出，key为null的entry数据的hash默认值是0.

并且默认是放到数组的第0个位置下。

private V putForNullKey(V value) {
        // 获取数组的第0个位置的元素进行遍厉链表，如果找到则替换
        for (Entry<K,V> 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++;
        // 如果没有找到则添加一个新的
        // 默认hash为0，数组角标为0
        addEntry(0, null, value, 0);
        return null;
    }

7.2 get key为null的数据

因为key为null的entry默认是放到数组的第0个位置，所以这里直接遍厉table[0]

如果没有找到则返回null即可

private V getForNullKey() {
        // 因为key为null的entry默认是放到数组的第0个位置，所以这里直接遍厉table[0]
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        // 如果没有找到则返回null即可
        return null;
    }

三、HashTable

HashTable的数据结构和HashMap的结构相同，HashTable是jdk1.0时候提供的（HashMap为jdk1.2提供），几乎所有的方法都加了synchronized关键字来保证线程安全。

HashTable的默认初识容量为11，加载因子为0.75

四、小结

1，加载因子为什么是0.75？

根据统计结果，当加载因子为0.75的时候，链表的长度几乎不会超过8，它实际使用空间换时间，让集合的put和get操作更快速。

2，为什么要用hashMap？

因为key-value结构，因为插入和获取都很快，

3，HashMap的底层数据结构？

当前是基于jdk1.7:底层为数组+链表的结构

4，HashMap和HashTable有什么不同？

HashMap线程不安全，不支持并发；

HashTable是线程安全的，可以支持并发访问。