Java源码之HashMap

一、HashMap和Hashtable的区别

(1)HashMapl的键值(key)和值(value)可以为null,而Hashtable不可以

(2)Hashtable是线程安全类，而HashMap为非线程安全类（HashMap是非synchronized，而Hashtable是synchronized）

(3)由于Hashtable是线程安全，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。

源码解析

HasgMap

Hashtable

二、如何使HashMap线程安全

Map m = Collections.synchronizeMap(hashMap);

三、详解HashMap

HashMap两种声明方式

1. Map<String> hashMap = new HashMap<String>();
2. HashMap<String> hashMap = new HashMap<String>();

异同：

  优点：

①灵活，符合java中所倡导的面向接口编程，例如如果项目需求不继续使用HashMap，而是改成TreeMap时，可以Map<String> hashMap = new TreeMap<String>();

         ②第一种声明方式是：父类的引用指向子类的对象,是多态的一种表现形式，实现了多态，多态后就可以写出一段所有子类都通用的代码，当添加新的子类时，这段代码是不需要修改的。
           父类的引用指向子类的对象的好处：多态、动态链接，向上转型。
缺点：
        ①无法调用HashMap特有的方法。

stackoverflow链接：http://stackoverflow.com/questions/1348199/

HashMap源码解析


                   链拉法


（1）put函数实现

①求key的hashcode(),然后再对key的hashcode求它的hash值

②如果发生Hash碰撞，则比较key值，如果还相等，以链表的形式放在同一个Bucket中，但不同Entry

③如果没发生Hash碰撞，直接放入Bucket中。

④ 如果binCount>=TREEIFY_THRESHOLD - 1,就会有链表编程红黑树（TREEIFY_THRESHOLD=8）

⑤如果节点存在（比较过hash与key），则直接覆盖旧value

⑥如果bucket达到临界值（超过load factor*current capacity）,就进行扩容

 public V put(K key, V value) {
         return putVal(hash(key), key, value, false, true);
     }

 static final int hash(Object key) {
         int h;
         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
     }

  static final int TREEIFY_THRESHOLD = 8;

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                    boolean evict) {
         Node<K,V>[] tab; Node<K,V> p; int n, i;
         if ((tab = table) == null || (n = tab.length) == 0)
             n = (tab = resize()).length;
           //计算是哪一个bucket,并把头节点返回p
         if ((p = tab[i = (n - 1) & hash]) == null)
               //如果该bucket为空，则新建节点，放入该bucket中
             tab[i] = newNode(hash, key, value, null);
         else {
             Node<K,V> e; K k;
               //key先比较hash值，如果hash值相等，再比较key值，如果hash与key都相等，则覆盖
             if (p.hash == hash &&
                 ((k = p.key) == key || (key != null && key.equals(k))))
                 e = p;
               //如果实例p是TreeNode类型，则放进红黑树种
             else if (p instanceof TreeNode)
                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
               //链表处理
             else {
                   //通过循环来插入后续节点
                 for (int binCount = 0; ; ++binCount) {
                       //插入链表中,采用头插法，e = p.next,p.next=newNode,p = e;
                     if ((e = p.next) == null) {
                         p.next = newNode(hash, key, value, null);
                           //如果binCount>=7,就会有链表编程红黑树
                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                             treeifyBin(tab, hash);
                         break;
                     }
                       //判断链表中是否循环到hash相同，key相同的Entry
                     if (e.hash == hash &&
                         ((k = e.key) == key || (key != null && key.equals(k))))
                         break;
                     p = e;
                 }
             }
               //如果Hash值相同，且key相等，则覆盖
             if (e != null) { // existing mapping for key
                 V oldValue = e.value;
                 if (!onlyIfAbsent || oldValue == null)
                     e.value = value;
                 afterNodeAccess(e);
                 return oldValue;
             }
         }
         ++modCount;
         if (++size > threshold)
             resize();
         afterNodeInsertion(evict);
         return null;
     }