HashMap的底层原理

HashMap的结构

HashMap在初始化时，会创建一个默认长度为16的Entry数组。这个数组里可以存储元素的位置被称为“桶（bucket）”，每个 bucket 都有其指定索引，系统可以根据其索引快速访问该 bucket 里存储的元素。

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

当进行put操作时，系统根据key计算所得的Hash值将Entry对象存储到数组中对应的位置。这个Entry对象包含hash,key,value,next.其中next用于指向下一个Entry对象。这样，就形成了数组-链表的形式。

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

put()操作详解

public V put(K key, V value) {
        if (key == null) //当key为null时，调用putForNullKey()
            return putForNullKey(value);
        int hash = hash(key.hashCode());//根据key计算hash值
        int i = indexFor(hash, table.length);//根据hash值计算索引
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //i处中存在元素
            Object k;
            if (e.hash == hash && ((k = e.key) == key ||   
            key.equals(k))) 
            {
            //key值相等，产生冲突，保存新的value
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        //i处为空或者发生冲突的对象之间key值不同
        modCount++;//修改次数
        addEntry(hash, key, value, i);//添加对象
        return null;
    }

其中putForNullKey()的主要操作是：获取数组第一个元素的值，若为空，直接添加Entry对象。若不为空，对比该处链表上的每一个值，当存在key为null的对象，用新的value覆盖旧value值；否则将Entry对象插入到链表的头部。
根据hash值计算索引

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

由于length是2的幂次，hash& (length-1)正好等于hash%length的值。其中，利用与运算提高了程序运行的效率。
addEntry()

void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];//保存数组中的Entry对象
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);//超过阈值，扩容
    }

接下来，对获取操作做简要介绍
get()

public V get(Object key) {
        if (key == null)
            return getForNullKey(); //key为null
        int hash = hash(key.hashCode());
        //利用hash值查找指定下标的Entry对象，遍历链表
        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)))//存在key值
                return e.value;
        }
        return null;//未查找到
    }

remove()

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对象
        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)))) {//当找到key相等的对象
                modCount++;
                size--;
                if (prev == e)//删除值为链表第一个
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;//指针后移
            e = next;
        }

        return e;
    }

补充：
- 为什么要有modCount?
Iterator迭代器采用了Fail-Fast 机制 ，如果有其他线程修改map，那么将抛出ConcurrentModificationException。这一机制是通过modCount实现，modCount是由volatile修饰，它能保证线程间的可见性。对map的修改都将增加这个值，在迭代器初始化时会将这个值赋给迭代器的expectedModCount，在nextEntry/remove中会判断 modCount 跟 expectedModCount 是否相等，不等将抛出异常。
- 为什么还有hashCode?
如果没有hashCode方法，那么利用hash & ( length - 1 )，会有一个问题存在，运算结果的由低位决定。这样显然是不合理的，HashMap中的hashCode()方法它能保证32位值只要有一位改变就会改变hash值，这样高位变化也能反映在低位中，
- 为什么默认负载因子是0.75？
这是时间和空间成本上一种折衷，增大负载因子可以减少 Hash 表（就是那个 Entry 数组）所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。

参考：http://blog.csdn.net/wenyiqingnianiii/article/details/52204136