HashMap源码分析

继承关系

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

内部变量

 /**
     * The default initial capacity - MUST be a power of two.
     */
	//初始化table数组大小
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
	 //table数组的最大长度，2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
	 //table数组的扩容影响因子，默认保存的节点数量超过了 数组长度*factor 就double一下长度
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
	 //HashMap实现的底层数据结构，数组
    transient Entry[] table;

    /**
     * The number of key-value mappings contained in this map.
     */
	 //Map中保存的key-value节点数，用来判断数组扩容条件
    transient int size;

    /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
	 //扩容的阈值
    int threshold;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
	 //扩容因子可以由调用者传入
    final float loadFactor;

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    transient volatile int modCount;

HashMap数据存储示意图

Entry数据结构

HashMap的一个内部静态类

        final K key;
        V value;
	//当不同的key定位到table数组中同一个索引后，需要用链表把这些冲突的entry串起来
        Entry<K,V> next;
		
	//key.hashCode经过hash算法计算而来
        final int hash;

put过程

1.key如果是null，调用putForNullKey,在table[0]上的链表进行遍历：
    如果key为null存在，更新value,返回旧值
    如果不存在,调用addEntry，new一个Entry，key为null,hash位0,插入到table[0]上，插入到链表头部
2.key不为null,计算hash值,计算数组索引index
   int hash = hash(key.hashCode());
   int i = indexFor(hash, table.length);
  在索引为i的table[i]指向的链表上，进行遍历，
      如果key存在(key值相等,且hash值相等)，更新value ;  
      如果key不存在，调用addEntry(hash, key, value, i);

分析addEntry方法

void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

上面这段代码很简单了吧，就是在头部插入新的key-value,维护链表顺序，同时，如果保存的节点数大于阈值，则进行数组扩容

扩容分析

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
		//如果数组长度已经最大，将阈值改为Integer.MAX_VALUE，不做任何修改
        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);
            }
        }
}

删除key

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        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--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

如果你对链表这种数据结构很熟悉的话，上面这段代码就没什么意思了