HashMap 深入学习

区别：
   1 继承类不同：
    A.HashMap继承AbstractMap
    B.Hashtable继承Dictionary
    2
    执行效率不同：
    A.HashMap是非线程安全的，是Hashtable的轻量级实现，效率较高
    B.Hashtable是线程安全的，效率较低
    3
    put方法对key和value的要求不同
    A.HashMap允许Entry的key或value为null
    B.Hashtable不允许Entry的key或value为null，否则出现NullPointerException
    4
    有无contains方法
    A.HashMap没有contains方法
    B.Hashtable有contains方法
    END

注意事项

    注意：Hashtale是Syncchronize的，而HashMap是Asyncchronize的，当多个线程访问Hashtable时，Hashtable不需要自己为它的方法实现同步；而当多个线程访问HashMap时，需要通过Collections.synchronizedMap来同步HashMap。



一、HashMap的内部存储结构
Java中数据存储方式最底层的两种结构，一种是数组，另一种就是链表，数组的特点：连续空间，寻址迅速，但是在删除或者添加元素的时候需要有较大幅度的移动，所以查询速度快，增删较慢。而链表正好相反，由于空间不连续，寻址困难，增删元素只需修改指针，所以查询慢、增删快。有没有一种数据结构来综合一下数组和链表，以便发挥他们各自的优势？答案是肯定的！就是：哈希表。哈希表具有较快（常量级）的查询速度，及相对较快的增删速度，所以很适合在海量数据的环境中使用。一般实现哈希表的方法采用“拉链法”，我们可以理解为“链表的数组

从上图中，我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。它的内部其实是用一个Entity数组来实现的，属性有key、value、next。接下来我会从初始化阶段详细的讲解HashMap的内部结构。

一句话回答

如果任何人让我描述一下HashMap的工作机制的话，我就简单的回答：“基于Hash的规则”。这句话非常简单，但是要理解这句话之前，首先我们得了解什么是哈希，不是么？

什么是哈希

哈希简单的说就是对变量/对象的属性应用某种算法后得到的一个唯一的串，用这个串来确定变量/对象的唯一性。一个正确的哈希函数必须遵守这个准则。

当哈希函数应用在相同的对象或者equal的对象的时候，每次执行都应该返回相同的值。换句话说，两个相等的对象应该有相同的hashcode。

注：所有Java对象都从Object类继承了一个默认的hashCode()方法。这个方法将对象在内存中的地址作为整数返回，这是一个很好的hash实现，他确保了不同的对象拥有不同的hashcode。

关于Entry类的一点介绍

一个map的定义是：一个映射键（key）到值（value）的对象。非常简单对吧。

所以，在HashMap中一定有一定的机制来存储这些键值对。使得，HashMap有一个内部类Entry，看起来像这样。


   static class Entry<K,V> implements Map.Entry<K,V>  
   { 
           final K key; 
           V value; 
           Entry<K,V> next; 
           final int hash; 
           ...//More code goes here 
   }

当然，Entry类有属性用来存储键值对映射。key被final标记，除了key和value，我们还能看到两个变量next和hash。接下来我们试着理解这些变量的含义。

put()方法实际上做了什么

再进一步看put方法的实现之前，我们有必要看一看Entry实例在数组中的存储，HashMap中是这样定义的：


   /** 
        * The table, resized as necessary. Length MUST Always be a power of two. 
        */
       transient Entry[] table;

现在再来看put方法的实现。


   /** 
   * Associates the specified value with the specified key in this map. 
   * If the map previously contained a mapping for the key, the old 
   * value is replaced. 
   * 
   * @param key key with which the specified value is to be associated 
   * @param value value to be associated with the specified key 
   * @return the previous value associated with <tt>key</tt>, or 
   *&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>null</tt> if there was no mapping for <tt>key</tt>. 
   *&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (A <tt>null</tt> return can also indicate that the map 
   *&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; previously associated <tt>null</tt> with <tt>key</tt>.) 
   */
   public V put(K key, V value) { 
   if (key == null) 
   return putForNullKey(value); 
   int hash = hash(key.hashCode()); 
   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是null值被存在table[0]的位置，因为null的hashcode始终为0接下来，通过key的hashCode()方法计算了这个key的hash值，这个hash值被用来计算存储Entry对象的数组中的位置。JDK的设计者假设会有一些人可能写出非常差的hashCode()方法，会出现一些非常大或者非常小的hash值。为了解决这个问题，他们引入了另外一个hash函数，接受对象的hashCode()，并转换到适合数组的容量大小。

接着是indexFor(hash,table,length)方法，这个方法计算了entry对象存储的准确位置。

接下来就是主要的部分，我们都知道两个不相等的key对象可能拥有过相同的hashCode值，两个不同的对象是怎么存储在相同的位置[叫做bucket]呢？

答案是LinkedList。如果你记得，Entry类有一个next变量，这个变量总是指向链中的下一个变量，这完全符合链表的特点。

所以，在发生碰撞的时候，entry对象会被以链表的形式存储起来，当一个Entry对象需要被存储的时候，hashmap检查该位置是否已近有了一个entry对象，如果没有就存在那里，如果有了就检查她的next属性，如果是空，当前的entry对象就作为已经存储的entry对象的下一个节点，依次类推。

如果我们给已经存在的key存入另一个value会怎么样的？逻辑上，旧的value值将被替换掉。在检测了Entry对象的存储位置后，hashmap将会遍历那个位置的entry链表，判断链表中的entry的key是否与传入的key相同，相同则替换（e.hash == hash && ((k = e.key) == key || key.equals(k))）。

在这种方式下HashMap就能保证key的唯一性。

get方法的工作机制

现在我们已经了解了HashMap中存储键值对的机制。下一个问题是：怎样从一个HashMap中查询结果。

其实逻辑跟put是一样的，如果传入的key有匹配就将该位置的value返回，如果没有就返回null.


   /** 
   * Returns the value to which the specified key is mapped, 
   * or {@code null} if this map contains no mapping for the key. 
   * 
   * <p>More formally, if this map contains a mapping from a key 
   * {@code k} to a value {@code v} such that {@code (key==null ? k==null : 
   * key.equals(k))}, then this method returns {@code v}; otherwise 
   * it returns {@code null}.&nbsp; (There can be at most one such mapping.) 
   * 
   * <p>A return value of {@code null} does not <i>necessarily</i> 
   * indicate that the map contains no mapping for the key; it's also 
   * possible that the map explicitly maps the key to {@code null}. 
   * The {@link #containsKey containsKey} operation may be used to 
   * distinguish these two cases. 
   * 
   * @see #put(Object, Object) 
   */
   public V get(Object key) { 
   if (key == null) 
   return getForNullKey(); 
   int hash = hash(key.hashCode()); 
   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.equals(k))) 
   return e.value; 
   } 
   return null; 
   }

上面的代码看起来跟put()方法很像，除了if (e.hash == hash && ((k = e.key) == key || key.equals(k)))。

注意点

存储Entry对象的数据结构是一个叫做Entry类型的table数组。

数组中一个特定的索引位置称为bucket,因为它可以容纳一个LinkedList的第一个元素的对象。

Key对象的hashCode()需要用来计算Entry对象的存储位置。

Key对象的equals()方法需要用来维持Map中对象的唯一性。

get()和put()方法跟Value对象的hashCode和equals方法无关。

null的hashCode总是0，这样的Entry对象总是被存储在数组的第一个位置


如果数据大小是固定的，那么最好给HashMap设定一个合理的容量值
        根据上面的分析，HashMap的初始默认容量是16，默认加载因子是0.75，也就是说，如果采用HashMap的默认构造函数，当增加数据时，数据实际容量超过16*0.75=12时，HashMap就扩容，扩容带来一系列的运算，新建一个是原来容量2倍的数组，对原有元素全部重新哈希，如果你的数据有几千几万个，而用默认的HashMap构造函数，那结果是非常悲剧的，因为HashMap不断扩容，不断哈希，在使用HashMap的场景里，不会是多个线程共享一个HashMap,除非对HashMap包装并同步，由此产生的内存开销和cpu开销在某些情况下可能是致命的。


以上摘自http://itlab.idcquan.com/Java/advance/906116.html