Think in Java -- Holding Your Object(HashMap 深入分析)

  HashMap是我们在编程中经常使用的一个容器类，HashMap能提供很高效的。

• HashMap的初始化
• HashMap put
• HashMap get
• HashMap remove
• HashMap resize

HashMap初始化

HashMap中，存放数据是使用邻接表的方式，如下图

左边的头结点，在HashMap中使用的是一个table的Entry数组来表示的，当具有相同的hash值的key value对要添加到这个HashMap的时候，就会按照列表的形式连接在一起。

所以在初始化的时候，我们需要初始化这个table的大小，这个table的大小。这个参数，当我们在不指定的时候，是16。另外需要指出的是，这个值需要是一个2的n次方，所以当我们提供的数据不是一个n次方的时候，被增大到最接近的n次方的值。需要n次方的原因，是和Hashmap实现的原理相关的，

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

另外，在hash中还有一个重要的参数，就是这个hash的load因子，HashMap在初始值是0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;

HashMap add

这里我们想介绍一个HashMap中是怎么添加元素的

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        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;
    }

第一步是对key为null时的特殊的处理，我们将在后面进行介绍。当key不为null的时候，我们首先会使用HashMap中定义的一个Hash函数，对object的进行一次hash，所以这里需要注意了，HashMap中，不是直接使用hashcode的 。然后根据这个hash的值，找到对应的table中的一个地方进行存放。如果这个位置已经被其他object存放过了，就是用邻接表的方式，添加到这个列表中。如果是第一次添加的，则会调用addEntry方法进行添加，这个方法的添加，也就和邻接表的添加是一样的，只是在里面会进行size的判断，以及判断是否需要扩容了。

当我们对同一个key添加多次value的时候，这样我们会覆盖前面的值，保留最后一次的。这里判断两个key是不是一样的，首先是判断hash值是否一样，然后是使用equals方法进行判断的。

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为null的时候，在hashmap中，key为null的都是存放在table中0这个位置，所以仅仅这个特殊的处理，其他和不是为null的添加方式是一样的。

private V putForNullKey(V value) {
        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;
    }

HashMap get

首先我们计算这个key对应的hash值，找到table中对应的位置，然后寻找以这个位置为头指针的列表，找出和这个key相等的一个entry的key，这样我们就取出value了。

public V get(Object key) {
        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;
    }

HashMap remove

因为这里HashMap是使用邻接表的方式进行实现的，所以可以直接删除某一个HashMap中的元素，修改对应的列表中，不会对其他元素造成影响。首先找到对应的table中的问题之，然后接下来的问题就是删除列表中的某一个元素。

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;
    }

HashMap resize

当HashMap中，当table中使用率超过load_factor的时候，就要扩容这个table了。我们需要的把这个table扩大两个，然后转移全部的原来中的key value 对到新的table中就可以了。还是邻接表的一些操作。下面是从老的table转移到新的table的代码，主要是在老的table中找到非空的位置，这样以这个位置为头指针的列表要转移到新的table中去。

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);
            }
        }
    }

另外 hashMap在高并发的情况下，有死循环的情况，下面是两篇网上的分析文章，分析的很透彻。

http://xm-king.iteye.com/blog/962172

http://code.alibabatech.com/blog/dev_related_969/hashmap-result-in-improper-use-cpu-100-of-the-problem-investigated.html