private void resize(int newCapacity)

　　默认的价值加载因子为2/3,在重新哈希后，加载因子变为1/3.当哈希表中的条目数超出了加载因子与当前容量的乘积时，通过调用 reszie 方法将容量翻倍，重新进行哈希。增加桶数，重新哈希，可能相当昂贵。

　　private void resize(int newCapacity) {

　　// assert (newCapacity & -newCapacity) == newCapacity; // power of 2

　　int newLength = newCapacity * 2;

　　Object[] oldTable = table;

　　int oldLength = oldTable.length;

　　if (oldLength == 2*MAXIMUM_CAPACITY) { // can't expand any further

　　if (threshold == MAXIMUM_CAPACITY-1)

　　throw new IllegalStateException("Capacity exhausted.");

　　threshold = MAXIMUM_CAPACITY-1; // Gigantic map!

　　return;

　　}

　　if (oldLength >= newLength)

　　return;

　　Object[] newTable = new Object[newLength];

　　threshold = newLength / 3;

　　for (int j = 0; j < oldLength; j += 2) {

　　Object key = oldTable[j];

　　if (key != null) {

　　Object value = oldTable[j+1];

　　oldTable[j] = null;

　　oldTable[j+1] = null;

　　int i = hash(key, newLength); 这里重哈希了/

　　while (newTable[i] != null)

　　i = nextKeyIndex(i, newLength);

　　newTable[i] = key;

　　newTable[i + 1] = value;

　　}

　　}

　　table = newTable;

　　}

　　6、TreeMap

　　TreeMap 的实现就是红黑树数据结构，也就说是一棵自平衡的排序二叉树，这样就可以保证当需要快速检索指定节点。红黑树是一种自平衡排序二叉树，树中每个节点的值，都大于或等于在它的左子树中的所有节点的值，并且小于或等于在它的右子树中的所有节点的值，这确保红黑树运行时可以快速地在树中查找和定位的所需节点。 对于 TreeMap 而言，由于它底层采用一棵"红黑树"来保存集合中的 Entry,这意味这 TreeMap 添加元素、取出元素的性能都比 HashMap 低：当 TreeMap 添加元素时，需要通过循环找到新增 Entry 的插入位置，因此比较耗性能;当从 TreeMap 中取出元素时，需要通过循环才能找到合适的 Entry,也比较耗性能。但 TreeMap比 HashMap 的优势在于：TreeMap 中的所有 Entry 总是按 key 根据指定排序规则保持有序状态，TreeSet 中所有元素总是根据指定排序规则保持有序状态。

　　public class TreeMap

　　extends AbstractMap

　　implements NavigableMap, Cloneable, java.io.Serializable

　　{

　　/**

　　* The comparator used to maintain order in this tree map, or

　　* null if it uses the natural ordering of its keys.

　　*

　　* @serial

　　*/

　　private final Comparator comparator;

　　private transient Entry root = null;

　　/**

　　* The number of entries in the tree

　　*/

　　private transient int size = 0;

　　/**

　　* The number of structural modifications to the tree.

　　*/

　　private transient int modCount = 0;

　　/**

　　* Constructs a new, empty tree map, using the natural ordering of its

　　* keys. All keys inserted into the map must implement the {@link

　　* Comparable} interface. Furthermore, all such keys must be

　　* mutually comparable: k1.compareTo(k2) must not throw

　　* a ClassCastException for any keys k1 and

　　* k2 in the map. If the user attempts to put a key into the

　　* map that violates this constraint (for example, the user attempts to

　　* put a string key into a map whose keys are integers)， the

　　* put(Object key, Object value) call will throw a

　　* ClassCastException.

　　*/

　　public TreeMap() {

　　comparator = null;

　　}

　　/**

　　* Constructs a new, empty tree map, ordered according to the given

　　* comparator. All keys inserted into the map must be mutually

　　* comparable by the given comparator: comparator.compare(k1,

　　* k2) must not throw a ClassCastException for any keys

　　* k1 and k2 in the map. If the user attempts to put

　　* a key into the map that violates this constraint, the put(Object

　　* key, Object value) call will throw a

　　* ClassCastException.

　　*

　　* @param comparator the comparator that will be used to order this map.

　　* If null, the {@linkplain Comparable natural

　　* ordering} of the keys will be used.

　　*/

　　public TreeMap(Comparator comparator) {

　　this.comparator = comparator;

　　}

　　static final class Entry implements Map.Entry {

　　K key;

　　V value;

　　Entry left = null;

　　Entry right = null;

　　Entry parent;

　　boolean color = BLACK;

　　/**

　　* Make a new cell with given key, value, and parent, and with

　　* null child links, and BLACK color.

　　*/

　　Entry(K key, V value, Entry parent) {

　　this.key = key;

　　this.value = value;

　　this.parent = parent;

　　}

　　同样是支持有序状态，LinkedHashMap保存了记录的插入顺序，先插入的先遍历到，而TreeMap默认是按升序排，也可以指定排序的比较器，遍历的时候按升序遍历。这个TreeMap的实现比较复杂，有需要研究的朋友可以自行查看其源码。

　　最后，我们来讨论一下hashcode在Map中的重要性。从上面我们了解到Map主要是依赖Hash码来查找元素链表的。根据某个计算公式，使用hashcode找到Entry所在的段，最后遍历对应段的链表结构再次去对比hashcode以及key值，最后找到value.当key对象的hash方法设计不当时，可能导致单个链表数据量过大，最后线性查找性能下降，导致整个map的查找性能下降。