まず、私たちの共通のHashMapをよく理解して最初：
1、概要
、その1つのキーだけHashMapの地図ベースのインターフェイス、記憶素子は、道への鍵であり、キーは一意でなければなりませんので、NULL値のヌルと建設の使用を可能にハッシュマップにヌル、付加的な要素は無秩序である順序を保証しない、と同じに順次れません。HashMapのは、スレッドセーフです。
2、継承
パブリッククラスのHashMap <K、V>延びクラスAbstractMap <K、V>
用具地図<K、V>、Cloneableを、直列化
3の基本的な特性を示す。
= 1 << 4静的最終int型DEFAULT_INITIAL_CAPACITY ; // デフォルトの初期サイズ16
静的最終フロートDEFAULT_LOAD_FACTOR = 0.75F; //負荷係数0.75
静的最後のエントリ[] = {} EMPTY_TABLE <??>; //デフォルトの初期化アレイ
過渡INTサイズ; //ハッシュマップ内の要素の数
INTしきい値; // HashMapの容量を調整するかどうかを決定します
注：HashMapのは、拡張操作がタスクを非常に時間がかかり、我々は能力の地図を見積もることができれば、それは複数の拡大を避けるために、それをデフォルトの初期値を与えることが最善ですので。HashMapのスレッドが安全ではない、マルチスレッド環境でのConcurrentHashMapをお勧めします。
**
第二に、頻繁にとの違いは、HashMapのとのハッシュテーブルを尋ね
**
1、スレッドの安全性の
両方の主な違いのは、HashMapのは、スレッドセーフではないながら、ハッシュテーブルは、スレッドセーフであるということです。
スレッドの同期を確保するために、synchronizedキーワードに追加されたハッシュテーブルの実装方法、そのため比較的HashMapのパフォーマンスは高くなりますそれ以外の場合は必要な場合を除き、マルチスレッド環境で使用する場合に使用HashMapのは、コレクションを使用する必要がある場合、我々は通常のHashMapを使用することをお勧めします。スレッドセーフなコレクションを取得するためにsynchronizedMap（）メソッド。
注：Collections.synchronizedMap（）の実装原理は、クラスのコレクションSynchronizedMap内で定義されたこのクラスは、スレッドの同期を確保するために、同期メソッド呼び出しを使用して、Mapインタフェースを実装し、または私達は実際にはHashMapのインスタンス操作のコースを渡します、単にCollections.synchronizedMap（）メソッドは、私たちは、自動的にスレッドの同期を実装するための操作HashMapの中に同期を追加するために役立っていることを意味し、他のCollections.synchronizedXXの方法と同様に同様の原理です。
2は、別のヌルのため
のHashtableをキーとしてnullを許可していない間のHashMapのヌル、キーとして使用することができます
キーとしてHashMapのサポートNULL値けれども、しかし、この提案は、まだそのような使用を避けることであるため、問題が発生した場合に注意して使用し、ない場合ので、調査とそれは非常に面倒でした。
注：キーとしてハッシュマップがnullで、常に最初の配列にノードテーブルに格納されています。
3、継承構造の
HashMapのは、Mapインタフェースの実装で、HashTableには、Mapインターフェースと抽象クラスの辞書を実装しています。
図4は、初期容量の拡張
ハッシュマップ16、11のハッシュテーブルの初期容量の初期容量、双方0.75のフィルファクタがデフォルトです。
場合、現在の拡張のHashMapすなわち二重容量：容量2、膨張、すなわちハッシュテーブルである+1ダブル容量：容量 2 + 1。
図5に示すように、ハッシュ計算の二つの異なる方法
ハッシュテーブルハッシュ計算ハッシュコードキーが配列表の長さを直接モジュロとして使用されます
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;- 1
- 2
キーのハッシュコードに基づいて計算HashMapのハッシュは、より良いを得るために第2のハッシュ、ハッシュ値を行い、その後、配列の長さは、タッチテーブルです。
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
static int indexFor(int h, int length) {
return h & (length-1);- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
三、HashMapのデータ格納構造
。1、ハッシュマップと鎖配列は、格納されたデータを達成するために、
キー入力エンティティからなる各ペアは、エントリークラスが実際に次のページを有する片方向リンク・リスト構造で、キーと値のペアを格納するハッシュマップ使用エントリアレイをポインタは、あなたが問題のハッシュ衝突を解決するために、次のエントリのエンティティを接続することができます。
アレイストレージの間隔が、それは偉大な宇宙複雑で、連続、深刻なメモリフットプリントです。アレイ機能はあるが、アレイバイナリサーチ時間複雑度が小さい、（1）Oである：簡単に挿入し、問題を削除、アドレッシング。
離散リスト記憶部は、空間計算量が非常に小さいので、よりリラックスしたメモリを取るが、O（N）の大規模な時間複雑。機能の一覧は以下のとおりです。簡単に難しく、挿入および欠失に取り組みます。
从上图我们可以发现数据结构由数组+链表组成，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key.hashCode())%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。
HashMap里面实现一个静态内部类Entry，其重要的属性有 hash，key，value，next。
HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性，作用是指向下一个Entry。打个比方， 第一个键值对A进来，通过计算其key的hash得到的index=0，记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，现在怎么办？HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。**也就是说数组中存储的是最后插入的元素。**到这里为止，HashMap的大致实现，我们应该已经清楚了。
public V put(K key, V value) {
if (key == null)
return putForNullKey(value); //null总是放在数组的第一个链表中
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;
//如果key在链表中已存在，则替换为新value
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;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e); //参数e, 是Entry.next
//如果size超过threshold，则扩充table大小。再散列
if (size++ >= threshold)
resize(2 * table.length);
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
四、重要方法深度解析
1、构造方法
HashMap() //无参构造方法
HashMap(int initialCapacity) //指定初始容量的构造方法
HashMap(int initialCapacity, float loadFactor) //指定初始容量和负载因子
HashMap(Map<? extends K,? extends V> m) //指定集合，转化为HashMap- 1
- 2
- 3
- 4
HashMap提供了四个构造方法，构造方法中 ，依靠第三个方法来执行的，但是前三个方法都没有进行数组的初始化操作，即使调用了构造方法此时存放HaspMap中数组元素的table表长度依旧为0 。在第四个构造方法中调用了inflateTable()方法完成了table的初始化操作，并将m中的元素添加到HashMap中。
2、添加方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) { //是否初始化
inflateTable(threshold);
}
if (key == null) //放置在0号位置
return putForNullKey(value);
int hash = hash(key); //计算hash值
int i = indexFor(hash, table.length); //计算在Entry[]中的存储位置
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); //添加到Map中
return null;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
在该方法中，添加键值对时，首先进行table是否初始化的判断，如果没有进行初始化（分配空间，Entry[]数组的长度）。然后进行key是否为null的判断，如果key==null ,放置在Entry[]的0号位置。计算在Entry[]数组的存储位置，判断该位置上是否已有元素，如果已经有元素存在，则遍历该Entry[]数组位置上的单链表。判断key是否存在，如果key已经存在，则用新的value值，替换点旧的value值，并将旧的value值返回。如果key不存在于HashMap中，程序继续向下执行。将key-vlaue, 生成Entry实体，添加到HashMap中的Entry[]数组中。
3、addEntry()
/*
* hash hash值
* key 键值
* value value值
* bucketIndex Entry[]数组中的存储索引
* /
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length); //扩容操作，将数据元素重新计算位置后放入newTable中，链表的顺序与之前的顺序相反
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
添加到方法的具体操作，在添加之前先进行容量的判断，如果当前容量达到了阈值，并且需要存储到Entry[]数组中，先进性扩容操作，空充的容量为table长度的2倍。重新计算hash值，和数组存储的位置，扩容后的链表顺序与扩容前的链表顺序相反。然后将新添加的Entry实体存放到当前Entry[]位置链表的头部。在1.8之前，新插入的元素都是放在了链表的头部位置，但是这种操作在高并发的环境下容易导致死锁，所以1.8之后，新插入的元素都放在了链表的尾部。
4、获取方法：get
public V get(Object key) {
if (key == null)
//返回table[0] 的value值
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
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 != null && key.equals(k))))
return e;
}
return null;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
在get方法中，首先计算hash值，然后调用indexFor()方法得到该key在table中的存储位置，得到该位置的单链表，遍历列表找到key和指定key内容相等的Entry，返回entry.value值。
5、删除方法
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
删除操作，先计算指定key的hash值，然后计算出table中的存储位置，判断当前位置是否Entry实体存在，如果没有直接返回，若当前位置有Entry实体存在，则开始遍历列表。定义了三个Entry引用，分别为pre, e ,next。 在循环遍历的过程中，首先判断pre 和 e 是否相等，若相等表明，table的当前位置只有一个元素，直接将table[i] = next = null 。若形成了pre -> e -> next 的连接关系，判断e的key是否和指定的key 相等，若相等则让pre -> next ,e 失去引用。
6、containsKey
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : 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 != null && key.equals(k))))
return e;
}
return null;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
containsKey方法是先计算hash然后使用hash和table.length取摸得到index值，遍历table[index]元素查找是否包含key相同的值。
7、containsValue
public boolean containsValue(Object value) {
if (value == null)
return containsNullValue();
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
containsValue方法就比较粗暴了，就是直接遍历所有元素直到找到value，由此可见HashMap的containsValue方法本质上和普通数组和list的contains方法没什么区别，你别指望它会像containsKey那么高效。
五、JDK 1.8的 改变
図1に示すように、リンクされたリスト配列+ +赤黒木の実装を使用してハッシュマップ。
Jdk1.8でのHashMapの実装にいくつかの変更をしたが、基本的な考え方は、配列+リンクリストでなりませんでしたが、いくつかの場所で最適化され、代わりにこれらの変更で、次のを見、データ構造鎖長が閾値を超えた変更リストストレージアレイ+ +赤黒木は、（8）、リストが赤黒木に変換されます。パフォーマンスのさらなる増加。
2、簡単な分析法を置きます：
public V put(K key, V value) {
//调用putVal()方法完成
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断table是否初始化，否则初始化操作
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//计算存储的索引位置，如果没有元素，直接赋值
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//节点若已经存在，执行赋值操作
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//判断链表是否是红黑树
else if (p instanceof TreeNode)
//红黑树对象操作
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//为链表，
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表长度8，将链表转化为红黑树存储
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//key存在，直接覆盖
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
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;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
キーのノードがある場合はノーリターンがない場合は、Nullの古い値を返します。
オリジナル住所ます。https：//www.cnblogs.com/java-jun-world2099/p/9258605.html