/** * Hash table based implementation of theMapinterface. This * implementation provides all of the optional map operations, and permits *nullvalues and thenullkey. (TheHashMap* class is roughly equivalent toHashtable, except that it is * unsynchronized and permits nulls.) This class makes no guarantees as to * the order of the map; in particular, it does not guarantee that the order * will remain constant over time. * *

hash table 基于map 接口的實現(xiàn)。這個實現(xiàn)提供了所有的map操作選項，且允許null 值value和null 鍵 key。HashMap基本與Hashtable相等，除了非線程安全和允許null。HashMap不能確定map的固定順序，事實上，HashMap不能保證隨著時間推移，map的固定順序

This implementation provides constant-time performance for the basic * operations (getandput), assuming the hash function * disperses the elements properly among the buckets.? Iteration over * collection views requires time proportional to the "capacity" of the *HashMapinstance (the number of buckets) plus its size (the number * of key-value mappings).? Thus, it's very important not to set the initial * capacity too high (or the load factor too low) if iteration performance is * important. * *

如果hash方法將元素適當(dāng)?shù)闹糜谕爸?，實現(xiàn)的類能夠使得get和put等基本操作算法的時間復(fù)雜度為常量級別。在集合視圖上迭代需要的時間與HashMap實例的capacity（桶的數(shù)量）加上他的size（mapping中鍵值對的數(shù)量）的數(shù)量成正比。因此，如果該對象迭代使用的較多，則對于初始化時的capacity不應(yīng)設(shè)置過大（factor不應(yīng)設(shè)置過?。?/p>

An instance ofHashMap has two parameters that affect its * performance:initial capacityandload factor.? The *capacityis the number of buckets in the hash table, and the initial * capacity is simply the capacity at the time the hash table is created.? The *load factoris a measure of how full the hash table is allowed to * get before its capacity is automatically increased.? When the number of * entries in the hash table exceeds the product of the load factor and the * current capacity, the hash table isrehashed(that is, internal data * structures are rebuilt) so that the hash table has approximately twice the * number of buckets. * *

該部分與hashtable一樣，意思是初始化時的兩個重要參數(shù)，capacity和factor

As a general rule, the default load factor (.75) offers a good tradeoff * between time and space costs.? Higher values decrease the space overhead * but increase the lookup cost (reflected in most of the operations of the *HashMapclass, includinggetandput).? The * expected number of entries in the map and its load factor should be taken * into account when setting its initial capacity, so as to minimize the * number of rehash operations.? If the initial capacity is greater * than the maximum number of entries divided by the load factor, no * rehash operations will ever occur. * *

If many mappings are to be stored in aHashMapinstance, * creating it with a sufficiently large capacity will allow the mappings to * be stored more efficiently than letting it perform automatic rehashing as * needed to grow the table. * *

Note that this implementation is not synchronized.* If multiple threads access a hash map concurrently, and at least one of * the threads modifies the map structurally, itmustbe * synchronized externally.? (A structural modification is any operation * that adds or deletes one or more mappings; merely changing the value * associated with a key that an instance already contains is not a * structural modification.)? This is typically accomplished by * synchronizing on some object that naturally encapsulates the map. * * If no such object exists, the map should be "wrapped" using the * {@link Collections#synchronizedMap Collections.synchronizedMap} * method.? This is best done at creation time, to prevent accidental * unsynchronized access to the map:

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

注意：HashMap不是線程安全的，使用Collection.synchronizedMap在創(chuàng)建時包裝該類。

* *

The iterators returned by all of this class's "collection view methods" * arefail-fast: if the map is structurally modified at any time after * the iterator is created, in any way except through the iterator's own *removemethod, the iterator will throw a * {@link ConcurrentModificationException}.? Thus, in the face of concurrent * modification, the iterator fails quickly and cleanly, rather than risking * arbitrary, non-deterministic behavior at an undetermined time in the * future. * *

Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification.? Fail-fast iterators * throwConcurrentModificationExceptionon a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness:the fail-fast behavior of iterators

* should be used only to detect bugs.* *

This class is a member of the * * Java Collections Framework. * * @paramthe type of keys maintained by this map * @param the type of mapped values

*

* @author? Doug Lea

* @author? Josh Bloch

* @author? Arthur van Hoff

* @author? Neal Gafter

* @see? ? Object#hashCode()

* @see? ? Collection

* @see? ? Map

* @see? ? TreeMap

* @see? ? Hashtable

* @since? 1.2

*/