JAVA API HashMap 分析

AbstractMap:

數據結構：

Entry<K,V> 是 Map接口內部的一個接口,在具體的實現類中會被實現成不同靜態內部類,他們有不同的的鍵值對結構.
Set<K> keySet();
Collection<V> values();

transient volatile Set<K> keySet = null;
transient volatile AbstractCollection<V> values = null;
keySet，values被設置為第一次指向的對象.以后使用該對象通過public Set<K> keySet()和public Collection<V> values()方法獲得，
從中也知道了鍵在集合中是以Set形式存在，值是以Collection形式存在，Entry<K,V>也是以Set形式存在，當然它們本身都是有各自的類型。

抽象方法：

public abstract Set<Entry<K,V>> entrySet();
//下面的兩個方法都是依靠了這個抽象方法進行的編程。
private Iterator<Entry<K,V>> i = entrySet().iterator();//返回的是實現類中內部類HashIterator這個對象。
public Set<K> keySet() {
        if (keySet == null) {
            keySet = new AbstractSet<K>() {
                public Iterator<K> iterator() {
                    return new Iterator<K>() {

                        private Iterator<Entry<K,V>> i = entrySet().iterator();

                        public boolean hasNext() {
                            return i.hasNext();
                        }

                        public K next() {
                            return i.next().getKey();
                        }

                        public void remove() {
                            i.remove();
                        }
                        
                    };
                }

                public int size() {
                    return AbstractMap.this.size();
                }

                public boolean isEmpty() {
                    return AbstractMap.this.isEmpty();
                }

                public void clear() {
                    AbstractMap.this.clear();
                }

                public boolean contains(Object k) {
                    return AbstractMap.this.containsKey(k);
                }
            };
        }
        return keySet;
    }
public Collection<V> values() {
        if (values == null) {
            values = new AbstractCollection<V>() {
                public Iterator<V> iterator() {
                    return new Iterator<V>() {
                        private Iterator<Entry<K,V>> i = entrySet().iterator();

                        public boolean hasNext() {
                            return i.hasNext();
                        }

                        public V next() {
                            return i.next().getValue();
                        }

                        public void remove() {
                            i.remove();
                        }
                    };
                }

                public int size() {
                    return AbstractMap.this.size();
                }

                public boolean isEmpty() {
                    return AbstractMap.this.isEmpty();
                }

                public void clear() {
                    AbstractMap.this.clear();
                }

                public boolean contains(Object v) {
                    return AbstractMap.this.containsValue(v);
                }

                
            };
        }
        return values;
    }

方法：

public int size();
public boolean isEmpty();
public boolean containsValue(Object value);
public boolean containsKey();
public abstract Set<Entry<K,V>> entrySet();
//------------------------------------
public V get(Object key);
//存入key返回的是對應的值。
//-----------------------------------
public V put(K key, V value);
//必須要重寫不然直接拋出UnsupportedOperationException()異常。
//----------------------------------
public V remove(Object key);
public void putAll;
public void clear();
//-------------------------------------------------
public boolean equals(Object o);
//判斷兩個map是否相等，原理是把a中的key放到b的get()取得的value和a的value進行比較，一項不滿足就返回false;
//-------------------------------------------------
public int hashCode();
//把每個元素的hashCode()加起來返回：h += i.next().hashCode();
//---------------------------------------
 public String toString();
 clone();
//以上方法大多面向抽象的編程，很多函數里都有entrySet().iterator();

 

 

HashMap:

構造方法：

public HashMap() {
        this.loadFactor =DEFAULT_LOAD_FACTOR;// all otherfields defaulted
    }
public HashMap(intinitialCapacity) {
        this(initialCapacity,DEFAULT_LOAD_FACTOR);
}
 
public HashMap(intinitialCapacity,floatloadFactor) {
      
}
public HashMap(Map<?extends K, ?extends V>m) {
    
}

1. capacity，表示的是HashMap中桶的數量，初始化容量initCapacity為16，第一次擴容會擴到64，之后每次擴容都是之前容量的2倍，所以容量每次都是2的次冪;
2. loadFactor，裝載因子，衡量HashMap一個滿的程度，初始化為0.75，實時裝載因子是size/capacity;
3. threshold，HashMap擴容的一個標准，每當size大於這個標准時就會進行擴容操作,threshold等於capacity*loadFactor;

數據結構:

static final Entry<?,?>[] EMPTY_TABLE = {};
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

集合特性：

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return newEntryIterator();
        }
        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> e = (Map.Entry<K,V>) o;
            Entry<K,V> candidate = getEntry(e.getKey());
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) {
            return removeMapping(o) != null;
        }
        public int size() {
            return size;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }

迭代器：

private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

HashIterator<Map.Entry<K,V>>是HashMap的內部類，其為抽象類，它沒有實現next（）方法，但是卻添加了具有next（）功能的函數nextEntry（）。

while (index < t.length && (next = t[index++]) == null)；

HashMap迭代的精髓就這句話。同樣說明了HashMap不能保證元素的順序。

HashMap的迭代器實現分成3種：

Iterator<V> newValueIterator()   {
        return new ValueIterator();
    }
    private final class ValueIterator extends HashIterator<V> {
        public V next() {
            return nextEntry().value;
        }
    }
    
    Iterator<K> newKeyIterator()   {
        return new KeyIterator();
    }
    private final class KeyIterator extends HashIterator<K> {
        public K next() {
            return nextEntry().getKey();
        }
    }

    Iterator<Map.Entry<K,V>> newEntryIterator()   {
        return new EntryIterator();
    }
    private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() {
            return nextEntry();
        }
    }

Map元素的迭代其實是其內部接口Entry<K,V>的實現的迭代，所以要迭代Map需要使用entrySet()方法取得Set<Entry<K,V>>類型的對象然后取得該對象的迭代器。
三個內部類中Values KeySet EntrySet。反而是EntrySet的迭代速度最快。

package test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class MapTest {
    
    public static <K> void main(String[] args) {
        
        Map<String,String> hashMap = new HashMap<String, String>();  
          
        for(int i=0;i<100000;i++)  
            hashMap.put(i+"", i+"v");  
          
        long time = System.currentTimeMillis(); 
        
        time = System.currentTimeMillis();  
        System.out.println("==============方式2：通過遍歷values()遍歷HashMap的value");  
        Collection<String> values = hashMap.values();  
        for(Iterator<String> valIt = values.iterator();valIt.hasNext();){  
            valIt.next();  
        }  
        System.out.println("用時:"+(System.currentTimeMillis() - time)); 
        
        System.out.println("==============方式1：通過遍歷keySet()遍歷HashMap的value");  
        Iterator<String> it = hashMap.keySet().iterator();  
        while(it.hasNext()){  
            it.next(); 
            //System.out.println(hashMap.get(it.next()));  
        }  
        System.out.println("用時:"+(System.currentTimeMillis() - time));  
        
        time = System.currentTimeMillis();  
        System.out.println("==============方式3：通過entrySet().iterator()遍歷HashMap的key和映射的value");  
        Iterator<Entry<String, String>> entryIt = hashMap.entrySet().iterator();  
        while(entryIt.hasNext()){  
             entryIt.next().getKey();  
             entryIt.next().getValue();  
            //System.out.println("key:"+entry.getKey()+" value:"+entry.getValue());  
        }  
        System.out.println("用時:"+(System.currentTimeMillis() - time)); 
    }
    
}

函數：

final int hash(Object k);
static int indexFor(int h, int length);

見JAVA API HashMap hash()函數解析.

private V getForNullKey();
private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

說明當key是null的時候會調用該函數，可以看到默認遍歷的是table[0]的位置,默認key==null的hashCode為0.

public V put(K key, V value);
public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        //Key的位置已經有舊的值了 則把新值給舊值 並返回舊值
        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++;
        //如果Key是新的則調用addEntry插入新的Key和value。
        addEntry(hash, key, value, i);
        return null;
    }

put函數保證了EntrySet集合中元素的唯一性。
((k = e.key) == key || key.equals(k))可見即使對象不同只要兩者的值相同就行，前提是重寫了toString().
從上面代碼我們同樣可以看出，不同的key可能散列出形同的hashCode,不同的hashCode可能定位到相同的table[i],所以在比較的時候要要同時判斷hashCode和key
如果遍歷完鏈表還沒有找到進入if語句的元素，說明可能發生了上面不同的key定位到了相同的table[i]的位置，所以就把這個新元素添加到表頭。

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++;
}

當中的形式參數e被賦值給了next,意識就是新的頭節點指向了舊的頭節點。

Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
}

在這里String對象是特殊的，在hash()函數中有。

if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
}

即使是不同的String對象只要值是相同的就認為是相同的key。