Java HashMap的工作原理
本文轉載於：http://www.importnew.com/10620.html
面試的時候經常會遇見諸如：“java中的HashMap是怎麽工作的”，“HashMap的get和put內部的工作原理”這樣的問題。本文將用一個簡單的例子來解釋下HashMap內部的工作原理。首先我們從一個例子開始，而不僅僅是從理論上，這樣，有助於更好地理解，然後，我們來看下get和put到底是怎樣工作的。
我們來看個非常簡單的例子。有一個”國家”(Country)類，我們將要用Country對象作為key，它的首都的名字（String類型）作為value。下面的例子有助於我們理解key-value對在HashMap中是如何存儲的。
1. Country.java
| 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 |
package org.arpit.javapostsforlearning;
public class Country {
String name;
long population;
public Country(String name, long population) {
super();
this.name = name;
this.population = population;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getPopulation() {
return population;
}
public void setPopulation(long population) {
this.population = population;
}
// If length of name in country object is even then return 31(any random number) and if odd then return 95(any random number).
// This is not a good practice to generate hashcode as below method but I am doing so to give better and easy understanding of hashmap.
@Override
public int hashCode() {
if(this.name.length()%2==0)
return 31;
else
return 95;
}
@Override
public boolean equals(Object obj) {
Country other = (Country) obj;
if (name.equalsIgnoreCase((other.name)))
return true;
return false;
}
}
|
如果想了解更多關於Object對象的hashcode和equals方法的東西，可以參考：
java中的hashcode()和equals()方法
2. HashMapStructure.java(main class)
| 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 |
import java.util.HashMap;
import java.util.Iterator;
public class HashMapStructure {
/**
* @author Arpit Mandliya
*/
public static void main(String[] args) {
Country india=new Country("India",1000);
Country japan=new Country("Japan",10000);
Country france=new Country("France",2000);
Country russia=new Country("Russia",20000);
HashMap<country,string> countryCapitalMap=new HashMap<country,string>();
countryCapitalMap.put(india,"Delhi");
countryCapitalMap.put(japan,"Tokyo");
countryCapitalMap.put(france,"Paris");
countryCapitalMap.put(russia,"Moscow");
Iterator<country> countryCapitalIter=countryCapitalMap.keySet().iterator();//put debug point at this line
while(countryCapitalIter.hasNext())
{
Country countryObj=countryCapitalIter.next();
String capital=countryCapitalMap.get(countryObj);
System.out.println(countryObj.getName()+"----"+capital);
}
}
}
|
現在，在第23行設置一個斷點，在項目上右擊->調試運行(debug as)->java應用(java application)。程序會停在23行，然後在countryCapitalMap上右擊，選擇“查看”（watch）。將會看到如下的結構：
從上圖可以觀察到以下幾點：
-
有一個叫做table大小是16的Entry數組。
-
這個table數組存儲了Entry類的對象。HashMap類有一個叫做Entry的內部類。這個Entry類包含了key-value作為實例變量。我們來看下Entry類的結構。Entry類的結構：
| 1 2 3 4 5 6 7 8 |
static class Entry implements Map.Entry
{
final K key;
V value;
Entry next;
final int hash;
...//More code goes here
} `
|
-
每當往hashmap裏面存放key-value對的時候，都會為它們實例化一個Entry對象，這個Entry對象就會存儲在前面提到的Entry數組table中。現在你一定很想知道，上面創建的Entry對象將會存放在具體哪個位置（在table中的精確位置）。答案就是，根據key的hashcode()方法計算出來的hash值（來決定）。hash值用來計算key在Entry數組的索引。
-
現在，如果你看下上圖中數組的索引10，它有一個叫做HashMap$Entry的Entry對象。
-
我們往hashmap放了4個key-value對，但是看上去好像只有2個元素！！！這是因為，如果兩個元素有相同的hashcode，它們會被放在同一個索引上。問題出現了，該怎麽放呢？原來它是以鏈表(LinkedList)的形式來存儲的(邏輯上)。
上面的country對象的key-value的hash值是如何計算出來的。
`
<code>Japan的Hash值是95，它的長度是奇數。 India的Hash值是95，它的長度是奇數。 Russia的Hash值是31，它的長度是偶數。 France，它的長度是偶數。 </code>
`
下圖會清晰的從概念上解釋下鏈表。
所以，現在假如你已經很好地了解了hashmap的結構，讓我們看下put和get方法。
Put :
讓我們看下put方法的實現：
| 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 |
/**
* 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 <tt>null</tt>
* if there was no mapping for <tt>key</tt>. (A <tt>null</tt> return
* can also indicate that the map 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的hash值總是0。
-
key的hashcode()方法會被調用，然後計算hash值。hash值用來找到存儲Entry對象的數組的索引。有時候hash函數可能寫的很不好，所以JDK的設計者添加了另一個叫做hash()的方法，它接收剛才計算的hash值作為參數。如果你想了解更多關於hash()函數的東西，可以參考：hashmap中的hash和indexFor方法
-
indexFor(hash,table.length)用來計算在table數組中存儲Entry對象的精確的索引。
-
在我們的例子中已經看到，如果兩個key有相同的hash值(也叫沖突)，他們會以鏈表的形式來存儲。所以，這裏我們就叠代鏈表。
- 如果在剛才計算出來的索引位置沒有元素，直接把Entry對象放在那個索引上。
- 如果索引上有元素，然後會進行叠代，一直到Entry->next是null。當前的Entry對象變成鏈表的下一個節點。
- 如果我們再次放入同樣的key會怎樣呢？邏輯上，它應該替換老的value。事實上，它確實是這麽做的。在叠代的過程中，會調用equals()方法來檢查key的相等性(key.equals(k))，如果這個方法返回true，它就會用當前Entry的value來替換之前的value。
Get:
現在我們來看下get方法的實現：
| 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 |
/**
* 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}. (There can be at most one such mapping.)
*
* </p><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;
}
|
當你理解了hashmap的put的工作原理，理解get的工作原理就非常簡單了。當你傳遞一個key從hashmap總獲取value的時候：
-
對key進行null檢查。如果key是null，table[0]這個位置的元素將被返回。
-
key的hashcode()方法被調用，然後計算hash值。
-
indexFor(hash,table.length)用來計算要獲取的Entry對象在table數組中的精確的位置，使用剛才計算的hash值。
-
在獲取了table數組的索引之後，會叠代鏈表，調用equals()方法檢查key的相等性，如果equals()方法返回true，get方法返回Entry對象的value，否則，返回null。
要牢記以下關鍵點：
- HashMap有一個叫做Entry的內部類，它用來存儲key-value對。
- 上面的Entry對象是存儲在一個叫做table的Entry數組中。
- table的索引在邏輯上叫做“桶”(bucket)，它存儲了鏈表的第一個元素。
- key的hashcode()方法用來找到Entry對象所在的桶。
- 如果兩個key有相同的hash值，他們會被放在table數組的同一個桶裏面。
- key的equals()方法用來確保key的唯一性。
- value對象的equals()和hashcode()方法根本一點用也沒有。
Java HashMap的工作原理