HashMap源码分析

一、数据结构

1、HashMap由内部类Entry的数组组成，该类是一个单向链表。

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
｝

    

二、基本属性

1、默认大小为16

static final int DEFAULT_INITIAL_CAPACITY = 16;

2、默认因子为0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;

3、阀值 ，大小为HashMap大小＊因子。

int threshold;

三、基本方法

1、默认构造方法。采用默认大小和默认因子，阀值为12.

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

2、put方法。

public V put(K key, V value) {
        //判断key是否为空，如果为空，增将它插入到头部
        if (key == null)
            return putForNullKey(value);
        //将key取hash值，再调用HashMap自己的hash方法。
        int hash = hash(key.hashCode());
        //获取当前的key散列完后所在数组的位置
        int i = indexFor(hash, table.length);           
        //如果当前的HashMap中存在该key，增替换该key的value，并且将原来的value返回。
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        //没有的话，则新增节点
        addEntry(hash, key, value, i);
        return null;
    }

private V putForNullKey(V value) {
        //null作为key一定要插入到数组的第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++;
        addEntry(0, null, value, 0);
        return null;
    }

void addEntry(int hash, K key, V value, int bucketIndex) {
        //获取新增key所在的数组头节点。
	Entry<K,V> e = table[bucketIndex];
        //将新增节点插入的头节点之前。
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        //如果此时数组大小超过阀值就需要resize。
        if (size++ >= threshold)
            resize(2 * table.length);
    }

3、get方法

public V get(Object key) {
        //如果key为null的话，只会在第0个数组上去找
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        //定位到数组具体位置，循环遍历单向链表。
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

4、resize方法

  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];
        //这个方法是关键，将旧数组转到新数组
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

void transfer(Entry[] newTable) {
        //获取旧数组
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                //对旧数组节点释放
                src[j] = null;
                do {
                    //临时存储当前节点的下一节点
                    Entry<K,V> next = e.next;
                    //获取当前节点在新数组中的位置
                    int i = indexFor(e.hash, newCapacity);
                    //将新数组中当前位置的节点指向当前节点
                    e.next = newTable[i];
                    //使当前节点作为新数组该位置的头部
                    newTable[i] = e;
                    //对下一个节点进行遍历
                    e = next;
                } while (e != null);
            }
        }
    }

5、removeEtryForKey方法

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        //定位当前key所在的数组位置
        int i = indexFor(hash, table.length);
        //存储前一节点 
        Entry<K,V> prev = table[i];
        //存储当前节点 Entry<K,V> e = prev; 
        while (e != null) { 
            Entry<K,V> next = e.next; 
            Object k; 
            if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { 
                modCount++; 
                size--;
                //这种情况发生的条件是：key正好是头节点的情况下，也就是第一次遍历，直接将当前节点的下一节点指向数组的当前位置。 
                if (prev == e)
                   table[i] = next;
                //非第一次遍历，之前存储的前一个节点直接指向当前节点的下一个节点 
                else 
                   prev.next = next; 
                e.recordRemoval(this); 
                return e; 
            }
            //将当前节点保存为前节点 
            prev = e;
            //获取下一个节点，继续遍历 
            e = next; 
        } 
        return e; 
}

四、总结

1、HashMap是一个由单向链表的构造的类，认真阅读并且思考源码后，对于单向链表的的理解，有非常大的提高。

2、通过对源码的阅读，知道了HashMap在什么情况下进行resize。可以在初始化时进行最优考虑，尽量避免resize的发生。

3、HashMap和HashTable的主要区别有两点：HashMap可以以null作为key进行插入，而HashTable不行。HashTable中的方法都加入了synchronized关键字。