import java.util.Map;public class Test {public static void main(String[] args) {Map<Key, String> map = new HashMap<Key, String>();map.put(new Key("A"), "1");map.put(new Key("B"), "2");map.put(new Key("C"), "3");System.out.println(map);}
}class Key {private String name;Key(String name) {this.name = name;}@Overridepublic int hashCode() {return 1;}@Overridepublic String toString() {return "Key [name=" + name + "]";}
}

import java.util.Map;public class Test {public static void main(String[] args) {Map<Key, Integer> map = new HashMap<Key, Integer>();for (int i = 0; i < 11; i++) {map.put(new Key(System.nanoTime()), i);}System.out.println(map);}
}class Key {private long name;Key(long name) {this.name = name;}@Overridepublic int hashCode() {return 1;}@Overridepublic String toString() {return "Key [name=" + name + "]";}
}

    static final int TREEIFY_THRESHOLD = 8;static final int UNTREEIFY_THRESHOLD = 6;static final int MIN_TREEIFY_CAPACITY = 64;

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {Node<K, V>[] tab;Node<K, V> p;int n, i;// 1 table 为空时重置大小if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;// 2  落到空bin 直接添加节点if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);// 3  落到非空bin ,判断 a , b ,c,else {Node<K, V> e;K k;// a) header与入参key相同，替换旧值if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))e = p;// b) header是红黑树去添加树节点else if (p instanceof TreeNode)e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);// c) header是链else {// 遍历链，逐项检查 ，判断 I ,IIfor (int binCount = 0;; ++binCount) {// I) 末尾追加节点并检查是否需要转为红黑树if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);break;}// II) key相同则替换旧值 返回if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;// 表中元素个数大于临界值时，扩展表X2if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

    final Node<K, V> getNode(int hash, Object key) {Node<K, V>[] tab;Node<K, V> first, e;int n;K k;// table 存在，header节点存在if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {// 与 header 节点key相同，返回header 节点if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))return first;// 如果存在header的子节点if ((e = first.next) != null) {// 如果 header 是红黑树去取树节点if (first instanceof TreeNode)return ((TreeNode<K, V>) first).getTreeNode(hash, key);// 如果 header 是链do {// 遍历节点，找到相同key返回if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}// 未查到相同keyreturn null;}

    final void treeifyBin(Node<K, V>[] tab, int hash) {int n, index;Node<K, V> e;// 如果table达不到最小treeify 容量(64)则扩容X2if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();// header 节点存在时else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode<K, V> hd = null, tl = null;// 遍历链将 Node -> TreeNodedo {TreeNode<K, V> p = replacementTreeNode(e, null);if (tl == null)hd = p;else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);if ((tab[index] = hd) != null)// 绘制红黑树
                hd.treeify(tab);}}

    /*** Initializes or doubles table size.  If null, allocates in* accord with initial capacity target held in field threshold.* Otherwise, because we are using power-of-two expansion, the* elements from each bin must either stay at same index, or move* with a power of two offset in the new table.** @return the table*/final Node<K, V>[] resize() {...return newTab;}

    /*** Computes key.hashCode() and spreads (XORs) higher bits of hash* to lower.  Because the table uses power-of-two masking, sets of* hashes that vary only in bits above the current mask will* always collide. (Among known examples are sets of Float keys* holding consecutive whole numbers in small tables.)  So we* apply a transform that spreads the impact of higher bits* downward. There is a tradeoff between speed, utility, and* quality of bit-spreading. Because many common sets of hashes* are already reasonably distributed (so don't benefit from* spreading), and because we use trees to handle large sets of* collisions in bins, we just XOR some shifted bits in the* cheapest possible way to reduce systematic lossage, as well as* to incorporate impact of the highest bits that would otherwise* never be used in index calculations because of table bounds.*/static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}