HashMap的实现

HashMap与HashTable的区别

• HashMap不是线程安全的，而HashTable是线程安全的，但是最好用ConcurrentHashMap代替。或Map m = Collections.synchronizeMap(hashMap)

• 两者的继承类也不同

• HashTable的key和value都不可以是null, ConcurrentHashMap也一样。而HashMap可以有一个键（只能一个）为null，而value的值可以为null。用HashMap的get()方法返回null，有2种可能（1.没有该键；2.该键对应的值为null），所以应该用containsKey()方法来判断。

• 哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值

---

HashMap的实现

• Map类型的实现类，要求key为不可变对象，即其hashCode不能改变，如果发生改变的话，Map对象就可能定位不到映射的value。

• 从实现来说：由数组+单链表+红黑树(1.8新增)

• 数组：transient Node<K,V>[] table;初始化和扩展数组在resize()方法内，在第一次调用HashMap的put()时会去初始化数组，默认大小为16，门槛threshold为size*0.75，当put等操作后会判断是否需要去扩充。

• 单链表：Node实现自Map.Entry接口

Fields Methods final int hash K getKey() K key V getValue() V value V setValue()=>用于更新 Node<K,V> next hashCode(), equal(), toString()

*

• #### 计算hash

static final int hash(Object key) {   //jdk1.8 & jdk1.7     int h;     // h = key.hashCode() 为第一步 取hashCode值     // h ^ (h >>> 16)  为第二步 取高16位与低16位参与异或运算     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

• put()操作

 1 public V put(K key, V value) { 2     // 对key的hashCode()做hash 3     return putVal(hash(key), key, value, false, true); 4 } 5 6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, 7                boolean evict) { 8     Node<K,V>[] tab; Node<K,V> p; int n, i; 9     // 步骤①：tab为空则创建10     if ((tab = table) == null || (n = tab.length) == 0)11         n = (tab = resize()).length;12     // 步骤②：计算index，并对null做处理 13     if ((p = tab[i = (n - 1) & hash]) == null) 14         tab[i] = newNode(hash, key, value, null);15     else {16         Node<K,V> e; K k;17         // 步骤③：节点key存在，直接覆盖value18         if (p.hash == hash &&19             ((k = p.key) == key || (key != null && key.equals(k))))20             e = p;21         // 步骤④：判断该链为红黑树22         else if (p instanceof TreeNode)23             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);24         // 步骤⑤：该链为链表25         else {26             for (int binCount = 0; ; ++binCount) {27                 if ((e = p.next) == null) {28                     p.next = newNode(hash, key,value,null);                        //链表长度大于8转换为红黑树进行处理29                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  30                         treeifyBin(tab, hash);31                     break;32                 }                    // key已经存在直接覆盖value33                 if (e.hash == hash &&34                     ((k = e.key) == key || (key != null && key.equals(k))))                        break;36                 p = e;37             }38         }39        40         if (e != null) { // existing mapping for key41             V oldValue = e.value;42             if (!onlyIfAbsent || oldValue == null)43                 e.value = value;44             afterNodeAccess(e);45             return oldValue;46         }47     }48     ++modCount;49     // 步骤⑥：超过最大容量 就扩容50     if (++size > threshold)51         resize();52     afterNodeInsertion(evict);53     return null;54 }

• resize()方法

 1 final Node<K,V>[] resize() { 2     Node<K,V>[] oldTab = table; 3     int oldCap = (oldTab == null) ? 0 : oldTab.length; 4     int oldThr = threshold; 5     int newCap, newThr = 0; 6     if (oldCap > 0) { 7         // 超过最大值就不再扩充了，就只好随你碰撞去吧 8         if (oldCap >= MAXIMUM_CAPACITY) { 9             threshold = Integer.MAX_VALUE;10             return oldTab;11         }12         // 没超过最大值，就扩充为原来的2倍13         else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&14                  oldCap >= DEFAULT_INITIAL_CAPACITY)15             newThr = oldThr << 1; // double threshold16     }17     else if (oldThr > 0) // initial capacity was placed in threshold18         newCap = oldThr;19     else {               // zero initial threshold signifies using defaults20         newCap = DEFAULT_INITIAL_CAPACITY;21         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);22     }23     // 计算新的resize上限24     if (newThr == 0) {2526         float ft = (float)newCap * loadFactor;27         newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?28                   (int)ft : Integer.MAX_VALUE);29     }30     threshold = newThr;31     @SuppressWarnings({"rawtypes"，"unchecked"})32         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];33     table = newTab;34     if (oldTab != null) {35         // 把每个bucket都移动到新的buckets中36         for (int j = 0; j < oldCap; ++j) {37             Node<K,V> e;38             if ((e = oldTab[j]) != null) {39                 oldTab[j] = null;40                 if (e.next == null)41                     newTab[e.hash & (newCap - 1)] = e;42                 else if (e instanceof TreeNode)43                     ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);44                 else { // 链表优化重hash的代码块45                     Node<K,V> loHead = null, loTail = null;46                     Node<K,V> hiHead = null, hiTail = null;47                     Node<K,V> next;48                     do {49                         next = e.next;50                         // 原索引51                         if ((e.hash & oldCap) == 0) {52                             if (loTail == null)53                                 loHead = e;54                             else55                                 loTail.next = e;56                             loTail = e;57                         }58                         // 原索引+oldCap59                         else {60                             if (hiTail == null)61                                 hiHead = e;62                             else63                                 hiTail.next = e;64                             hiTail = e;65                         }66                     } while ((e = next) != null);67                     // 原索引放到bucket里68                     if (loTail != null) {69                         loTail.next = null;70                         newTab[j] = loHead;71                     }72                     // 原索引+oldCap放到bucket里73                     if (hiTail != null) {74                         hiTail.next = null;75                         newTab[j + oldCap] = hiHead;76                     }77                 }78             }79         }80     }81     return newTab;82 }

• 非线程安全

• 在put()方法中会遍历链表，在多线程情况链表会成环。造成死循环。

• 链表转为红黑树

final void treeify(Node<K,V>[] tab) {            TreeNode<K,V> root = null;            for (TreeNode<K,V> x = this, next; x != null; x = next) {                next = (TreeNode<K,V>)x.next;                x.left = x.right = null;                if (root == null) {                    x.parent = null;                    x.red = false;                    root = x;                }                else {                    K k = x.key;                    int h = x.hash;                    Class<?> kc = null;                    for (TreeNode<K,V> p = root;;) {                        int dir, ph;                        K pk = p.key;                        if ((ph = p.hash) > h)                            dir = -1;                        else if (ph < h)                            dir = 1;                        else if ((kc == null &&                                  (kc = comparableClassFor(k)) == null) ||                                 (dir = compareComparables(kc, k, pk)) == 0)                            dir = tieBreakOrder(k, pk);                        TreeNode<K,V> xp = p;                        if ((p = (dir <= 0) ? p.left : p.right) == null) {                            x.parent = xp;                            if (dir <= 0)                                xp.left = x;                            else                                xp.right = x;                            root = balanceInsertion(root, x);                            break;                        }                    }                }            }            moveRootToFront(tab, root);        }

---

HashSet的实现，和HashMap的区别

• 都实现了Set接口，仅存储不同的对象。

• HashSet内部封装了一个HashMap对象，仅保存不同的Object作为键。内部有一个private static final Object PRESENT = new Object();作为所有键的值

• TreeSet内部封装一个NavigableMap引用，默认构造器传入一个TreeMap对象，也可以传入别的实现NavigableMap接口的对象。（JDK中另一个实现的叫ConcurrentSkipListSet）

• LinkedHashSet调用父类HashSet的构造器，改为封装一个LinkedHashMap。LinkedHashMap继承了HashMap,其内部重写了newNode()方法【put()的底层实现】，当调用put()的时候会将先将这个节点放进一个双链表的尾部，为的是遍历Set时候能按照添加顺序来。