java源码分析02-HashMap

今天很开心，希望她能是我心中所期待的那位。

总结前段时间的面试，其中有一个问题特别频繁，那就是HashMap与Hashtable的区别。一般人看到这个问题就会想到java面试宝典上的答案，例如是否线程安全，key和value能否为空，contains方法存在歧义，默认容量以及扩容方式不一样等。

其实，这里考察的是我们对HashMap这个集合的理解。

首先，HashMap从使用的角度来看，就是存放键值对的并提供快速查询机制的，这种集合当然可以用作缓存。

其次，从增删改查的角度，使用HashMap的几个方法，put(key,value),remove(key),containsKey(key)以及集合的迭代输出；

这些方法的使用让我对它的内部有些好奇，首先是如果添加key相同的对象，最后输出的是后来添加的value，刚开始我很疑惑，虽然结果已经告诉我，事实就是如此，但是我还是想去了解她内心到底是怎么想的。

于是，我打开了HashMap的源码，发现他的内部既然也是数组形式存储的，这让我对她的快速查询有了一丝质疑，难道她也是顺序存储的吗？

继续看下去，发现

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

       

 public V put(K key, V value) {        if (table == EMPTY_TABLE) {            inflateTable(threshold);        }        if (key == null)            return putForNullKey(value);        int hash = hash(key);        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的哈希值，继而确定该对象在数组

中的下标值；第三，可能会出现key的哈希值相同的情况，也就是出现冲突，每次都是先保存之前的value，然后存储现有的value，但是此处不能看出，HashMap对于冲突对象是怎么处理的；第四，对于没有发生冲突的，通过addEntry方法，将对象加入到数组中。

那么，它是怎么实现快速查询的呢？

 public V get(Object key) {        if (key == null)            return getForNullKey();        Entry<K,V> entry = getEntry(key);        return null == entry ? null : entry.getValue();    }

final Entry<K,V> getEntry(Object key) {        if (size == 0) {            return null;        }        int hash = (key == null) ? 0 : hash(key);        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 != null && key.equals(k))))                return e;        }        return null;    }

上述代码告诉我们，第一，key为空会单独查询，那么为什么呢？

 private V getForNullKey() {        if (size == 0) {            return null;        }        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null)                return e.value;        }        return null;    }

上述代码告诉我们，原来key为空是存在下标为0的位置，那么为什么还需要一个for循环以及类似链表遍历的结构来查询呢？

         我猜测可能是防止使用反射机制给Entry数组设值得情况，而且我们获取的始终是第一个key为null的value。

第二，当我们根据key获取value的时候，也是先计算对象在数组中的下标值，然后找到相应的对象，如果key相同或相等，就可以取出。

我在想，她会不会是那种适合过日子的女生呢？

她的初试容量是多大，如果生气，每次能扩大多少容量？

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

可能存在生气的地方是如果我又多了一个女性朋友。

void addEntry(int hash, K key, V value, int bucketIndex) {        if ((size >= threshold) && (null != table[bucketIndex])) {            resize(2 * table.length);            hash = (null != key) ? hash(key) : 0;            bucketIndex = indexFor(hash, table.length);        }        createEntry(hash, key, value, bucketIndex);    }

从上面可以看到，她心里有一个承受极限threshold，如果超过了，不知道会发生什么。

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, initHashSeedAsNeeded(newCapacity));        table = newTable;        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);    }

这里告诉我们，她的心里承受能力还是分级别的，比如和女生说话，和女生走在一起，和女生吃饭，和女生逛街，和女生看电影等等

但是，她也有一个极限，就是。。。。你懂的

那时候她就会换男朋友了。。。

void transfer(Entry[] newTable, boolean rehash) {        int newCapacity = newTable.length;        for (Entry<K,V> e : table) {            while(null != e) {                Entry<K,V> next = e.next;                if (rehash) {                    e.hash = null == e.key ? 0 : hash(e.key);                }                int i = indexFor(e.hash, newCapacity);                e.next = newTable[i];                newTable[i] = e;                e = next;            }        }    }

关于扩容是否需要重新计算哈希值，并储存