HashMap解析

         HashMap是基于哈希表的Map接口的实现，实际上是数组和链表的组合，允许null值和null键（HashMap和Hashtable大致一样，除了不同步和允许null外）。HashMap不保存映射的顺序，特别是不保证该顺序恒久不变。

         HashMap的实现假定hash函数将各个元素正确分布在各桶之间，可为基本操作（如get()和set()）提供稳定的性能，迭代集合视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）的和成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。 （注：这段同HashSet很相似，其实HashSet是基本HashMap实现的，所以在性能的控制上也一样）

         HashMap 的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，通过调用 rehash 方法将容量翻倍。HashMap的默认初始容量是16，默认加载因子是0.75，这样，当HashMap里的元素超过16*0.75即12时，调用rehash方法，使容量增长一倍。

        通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地降低 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

        如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。       

          注意，此实现不是同步的。 如果多个线程同时访问此映射，而其中至少一个线程从结构上修改了该映射，则它必须 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示： 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用

           Map m = Collections.synchronizedMap(new HashMap(...));

           由所有此类的“集合视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException 。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间任意发生不确定行为的风险。

         注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException 。因此，编写依赖于此异常程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。 HashMap的构造函数：

 

public HashMap(int initialCapacity, float loadFactor) {       
                if (initialCapacity < 0)            
                       throw new IllegalArgumentException("Illegal initial capacity: " +  initialCapacity);        
                if (initialCapacity > MAXIMUM_CAPACITY)            
                       initialCapacity = MAXIMUM_CAPACITY;        
                if (loadFactor <= 0 || Float.isNaN(loadFactor))            
                       throw new IllegalArgumentException("Illegal load factor: " +  loadFactor);
                // Find a power of 2 >= initialCapacity       
                int capacity = 1;        
                while (capacity < initialCapacity)            
                    capacity <<= 1;        
                this.loadFactor = loadFactor;        
                threshold = (int)(capacity * loadFactor);        
                table = new Entry[capacity];        
                init();    
         }

         可以看出，当生成HashMap对象时，如果initialCapacity的数值比较大时，capacity 会被赋于等于或大于initialCapacity 的值，然后创建一个有capacity 个Entry对象的table数组，所以initialCapacity的数值不能太大，否则会生成比较大的数组table，占用比较大的应用内存，造成内存浪费。 HashMap的默认构造函数：

        public HashMap() {        
               this.loadFactor = DEFAULT_LOAD_FACTOR;        
               threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        
               table = new Entry[DEFAULT_INITIAL_CAPACITY];        
               init();    
        }

         默认构造函数里的初始容量为16，加载因子为0.75，这样会生成含有16*0.75=12个Entry对象的数组table，当HashMap里的元素数量超过12个时，会将HashMap的容量翻1倍，生成包含32个Entry对象的数组。

            put方法：

        public V put(K key, V value) {
        K k = maskNull(key);
        int hash = hash(k);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            if (e.hash == hash && eq(k, e.key)) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, k, value, i);
        return null;
    }

          K k = maskNull(key);这行是判断key是否为null，如果为null，则返回一个静态的K（Object）对象做为键值，这就是HashMap为什么允许null键存在的原因。

   int hash = hash(k);

        int i = indexFor(hash, table.length);

       这连续的两步就是 HashMap 最牛的地方！研究完我都汗颜了，其中 hash 就是通过 key 这个Object的 hashcode 进行 hash，然后通过 indexFor 获得在Object table的索引值。

       table？？？不要惊讶，其实HashMap也神不到哪里去，它就是用 table 来放的。最牛的就是用 hash 能正确的返回索引。
　　不知道大家有没有留意 put 其实是一个有返回的方法，它会把相同键值的 put 覆盖掉并返回旧的值！如下方法彻底说明了 HashMap 的结构，其实就是一个表加上在相应位置的Entry的链表：

for (Entry e = table; e != null; e = e.next) {
　if (e.hash == hash && eq(k, e.key)) {
　　Object oldvalue = e.value;
　　e.value = value; //把新的值赋予给对应键值。
　　e.recordAccess(this); //空方法，留待实现
　　return oldvalue; //返回相同键值的对应的旧的值。
　}
}
modCount++; //结构性更改的次数
addEntry(hash, k, value, i); //添加新元素，关键所在！
return null; //没有相同的键值返回
} 

 　　我们把关键的方法拿出来分析：

void addEntry(int hash, Object key, Object value, int bucketIndex) {
table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]); 

 　 　因为 hash 的算法有可能令不同的键值有相同的hash码并有相同的table索引，如：key＝“33”和key＝Object g的hash都是－8901334，那它经过indexfor之后的索引一定都为i，这样在new的时候这个Entry的next就会指向这个原本的 table，再有下一个也如此，形成一个链表，和put的循环对定e.next获得旧的值。到这里，HashMap的结构，大家也十分明白了吧？

if (size++ >= threshold)     //这个threshold就是能实际容纳的量
resize(2 * table.length);     //超出这个容量就会将Object table重构 

 　　所谓的重构也不神，就是建一个两倍大的table（我在别的论坛上看到有人说是两倍加1，把我骗了），然后再一个个indexfor进去！注意！！这就是效率！！如果你能让你的HashMap不需要重构那么多次，效率会大大提高！
　 　说到这里也差不多了，get比put简单得多，大家，了解put，get也差不了多少了。对于collections我是认为，它是适合广泛的，当不完 全适合特有的，如果大家的程序需要特殊的用途，自己写吧，其实很简单。（作者是这样跟我说的，他还建议我用LinkedHashMap,我看了源码以后发 现，LinkHashMap其实就是继承HashMap的，然后override相应的方法，有兴趣的同人，自己looklook）建个 Object table，写相应的算法，就ok啦。
　　举个例子吧，像 Vector，list 啊什么的其实都很简单，最多就多了的同步的声明，其实如果要实现像Vector那种，插入，删除不多的，可以用一个Object table来实现，按索引存取，添加等。
　　如果插入，删除比较多的，可以建两个Object table，然后每个元素用含有next结构的一个table存，如果要插入到i，但是i已经有元素，用next连起来，然后size＋＋，并在另一个table记录其位置。