站在巨人肩膀上看源碼-HashSet

時間 2019-12-05

標籤站在巨人肩膀上看源碼 hashset 欄目 Java 简体版

原文原文鏈接

1.HashSet概述：

　　HashSet實現Set接口，由哈希表（其實是一個HashMap實例）支持。它不保證set 的迭代順序；特別是它不保證該順序恆久不變。此類容許使用null元素。HashSet中不容許有重複元素，這是由於HashSet是基於HashMap實現的，HashSet中的元素都存放在HashMap的key上面，而value中的值都是統一的一個private static final Object PRESENT = new Object();。HashSet跟HashMap同樣，都是一個存放鏈表的數組。java

　　HashSet中add方法調用的是底層HashMap中的put()方法，而若是是在HashMap中調用put，首先會判斷key是否存在，若是key存在則修改value值，若是key不存在這插入這個key-value。而在set中，由於value值沒有用，也就不存在修改value值的說法，所以往HashSet中添加元素，首先判斷元素（也就是key）是否存在，若是不存在這插入，若是存在着不插入，這樣HashSet中就不存在重複值。spring

2.HashSet的實現：

對於HashSet而言，它是基於HashMap實現的，HashSet底層使用HashMap來保存全部元素，更確切的說，HashSet中的元素，只是存放在了底層HashMap的key上，而value使用一個static final的Object對象標識。所以HashSet 的實現比較簡單，相關HashSet的操做，基本上都是直接調用底層HashMap的相關方法來完成，HashSet的源代碼以下：數組

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    // 底層使用HashMap來保存HashSet中全部元素。
    private transient HashMap<E,Object> map;
    
    // 定義一個虛擬的Object對象做爲HashMap的value，將此對象定義爲static final。
    private static final Object PRESENT = new Object();

    /**
     * 默認的無參構造器，構造一個空的HashSet。
      * 
     * 實際底層會初始化一個空的HashMap，並使用默認初始容量爲16和加載因子0.75。
      */
    public HashSet() {
        map = new HashMap<E,Object>();
    }

    /**
     * 構造一個包含指定collection中的元素的新set。
      *
     * 實際底層使用默認的加載因子0.75和足以包含指定
     * collection中全部元素的初始容量來建立一個HashMap。
     * @param c 其中的元素將存放在此set中的collection。
     */
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    /**
     * 以指定的initialCapacity和loadFactor構造一個空的HashSet。
     *
     * 實際底層以相應的參數構造一個空的HashMap。
     * @param initialCapacity 初始容量。
     * @param loadFactor 加載因子。
     */
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<E,Object>(initialCapacity, loadFactor);
    }

    /**
     * 以指定的initialCapacity構造一個空的HashSet。
     *
     * 實際底層以相應的參數及加載因子loadFactor爲0.75構造一個空的HashMap。
     * @param initialCapacity 初始容量。
     */
    public HashSet(int initialCapacity) {
        map = new HashMap<E,Object>(initialCapacity);
    }

    /**
     * 以指定的initialCapacity和loadFactor構造一個新的空連接哈希集合。
     * 此構造函數爲包訪問權限，不對外公開，實際只是是對LinkedHashSet的支持。
     *
     * 實際底層會以指定的參數構造一個空LinkedHashMap實例來實現。
     * @param initialCapacity 初始容量。
     * @param loadFactor 加載因子。
     * @param dummy 標記。
     */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
    }

    /**
     * 返回對此set中元素進行迭代的迭代器。返回元素的順序並非特定的。
     * 
     * 底層實際調用底層HashMap的keySet來返回全部的key。
     * 可見HashSet中的元素，只是存放在了底層HashMap的key上，
     * value使用一個static final的Object對象標識。
     * @return 對此set中元素進行迭代的Iterator。
     */
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    /**
     * 返回此set中的元素的數量（set的容量）。
     *
     * 底層實際調用HashMap的size()方法返回Entry的數量，就獲得該Set中元素的個數。
     * @return 此set中的元素的數量（set的容量）。
     */
    public int size() {
        return map.size();
    }

    /**
     * 若是此set不包含任何元素，則返回true。
     *
     * 底層實際調用HashMap的isEmpty()判斷該HashSet是否爲空。
     * @return 若是此set不包含任何元素，則返回true。
     */
    public boolean isEmpty() {
        return map.isEmpty();
    }

    /**
     * 若是此set包含指定元素，則返回true。
     * 更確切地講，當且僅當此set包含一個知足(o==null ? e==null : o.equals(e))
     * 的e元素時，返回true。
     *
     * 底層實際調用HashMap的containsKey判斷是否包含指定key。
     * @param o 在此set中的存在已獲得測試的元素。
     * @return 若是此set包含指定元素，則返回true。
     */
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    /**
     * 若是此set中還沒有包含指定元素，則添加指定元素。
     * 更確切地講，若是此 set 沒有包含知足(e==null ? e2==null : e.equals(e2))
     * 的元素e2，則向此set 添加指定的元素e。
     * 若是此set已包含該元素，則該調用不更改set並返回false。
     *
     * 底層實際將將該元素做爲key放入HashMap。
     * 因爲HashMap的put()方法添加key-value對時，當新放入HashMap的Entry中key
     * 與集合中原有Entry的key相同（hashCode()返回值相等，經過equals比較也返回true），
     * 新添加的Entry的value會將覆蓋原來Entry的value，但key不會有任何改變，
     * 所以若是向HashSet中添加一個已經存在的元素時，新添加的集合元素將不會被放入HashMap中，
     * 原來的元素也不會有任何改變，這也就知足了Set中元素不重複的特性。
     * @param e 將添加到此set中的元素。
     * @return 若是此set還沒有包含指定元素，則返回true。
     */
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    /**
     * 若是指定元素存在於此set中，則將其移除。
     * 更確切地講，若是此set包含一個知足(o==null ? e==null : o.equals(e))的元素e，
     * 則將其移除。若是此set已包含該元素，則返回true
     * （或者：若是此set因調用而發生更改，則返回true）。（一旦調用返回，則此set再也不包含該元素）。
     *
     * 底層實際調用HashMap的remove方法刪除指定Entry。
     * @param o 若是存在於此set中則須要將其移除的對象。
     * @return 若是set包含指定元素，則返回true。
     */
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

    /**
     * 今後set中移除全部元素。此調用返回後，該set將爲空。
     *
     * 底層實際調用HashMap的clear方法清空Entry中全部元素。
     */
    public void clear() {
        map.clear();
    }

    /**
     * 返回此HashSet實例的淺表副本：並無複製這些元素自己。
     *
     * 底層實際調用HashMap的clone()方法，獲取HashMap的淺表副本，並設置到HashSet中。
     */
    public Object clone() {
        try {
            HashSet<E> newSet = (HashSet<E>) super.clone();
            newSet.map = (HashMap<E, Object>) map.clone();
            return newSet;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }
}

3.示例：

接下來看一個示例程序，測試一下本身是否真正掌握了HashSet 集合的功能。函數

package com.spring.test;

import java.util.HashSet;
import java.util.Set;

class Name   
{   
    private String first;    
    private String last;    
       
    public Name(String first, String last)    
    {    
        this.first = first;    
        this.last = last;    
    }    
  
    public boolean equals(Object o)    
    {    
        if (this == o)    
        {    
            return true;    
        }    
           
        if (o.getClass() == Name.class)    
        {    
            Name n = (Name)o;    
            return n.first.equals(first)    
                && n.last.equals(last);    
        }    
        return false;    
    }    
} 

public class TestSet {
    
    public static void main(String[] args){
        
        Set<Name> s = new HashSet<Name>();   
        s.add(new Name("abc", "123"));   
        System.out.println(   
        s.contains(new Name("abc", "123")));

    }
}

上面程序中向 HashSet 裏添加了一個 new Name("abc", "123") 對象以後，當即經過程序判斷該 HashSet 是否包含一個 new Name("abc", "123") 對象。粗看上去，很容易覺得該程序會輸出 true。實際運行上面程序將看到程序輸出 false，這是由於 HashSet 判斷兩個對象相等的標準除了要求經過 equals() 方法比較返回 true 以外，還要求兩個對象的 hashCode() 返回值相等。而上面程序沒有重寫 Name 類的 hashCode() 方法，兩個 Name 對象的 hashCode() 返回值並不相同，所以 HashSet 會把它們當成 2 個對象處理，所以程序返回 false。
因而可知，當咱們試圖把某個類的對象當成 HashMap 的 key，或試圖將這個類的對象放入 HashSet 中保存時，重寫該類的 equals(Object obj) 方法和 hashCode() 方法很重要，並且這兩個方法的返回值必須保持一致：當該類的兩個的 hashCode() 返回值相同時，它們經過 equals() 方法比較也應該返回 true。一般來講，全部參與計算 hashCode() 返回值的關鍵屬性，都應該用於做爲 equals() 比較的標準。以下程序就正確重寫了 Name 類的 hashCode() 和 equals() 方法，程序以下：測試

package com.spring.test;

import java.util.HashSet;
import java.util.Set;

class Name   
{   
    private String first;    
    private String last;    
       
    public Name(String first, String last){    
        this.first = first;    
        this.last = last;    
    }    
    
    // 根據 first 判斷兩個 Name 是否相等   
    public boolean equals(Object o){    
        if (this == o){    
            return true;    
        }    
        
        if (o.getClass() == Name.class){    
            Name n = (Name)o;    
            return n.first.equals(first);    
        }    
        return false;    
    } 
    
    // 根據 first 計算 Name 對象的 hashCode() 返回值   
    public int hashCode(){    
        return first.hashCode();    
    }
    
    public String toString(){    
        return"Name[first=" + first + ", last=" + last + "]";    
    } 

} 

public class TestSet {
    
    public static void main(String[] args){
        
        Set<Name> set = new HashSet<Name>();   
        set.add(new Name("abc", "123"));
        set.add(new Name("abc", "456"));
        System.out.println(set);   
    }
}

上面程序中提供了一個 Name 類，該 Name 類重寫了 equals() 和 toString() 兩個方法，這兩個方法都是根據 Name 類的 first 實例變量來判斷的，當兩個Name 對象的 first 實例變量相等時，這兩個 Name 對象的 hashCode() 返回值也相同，經過 equals() 比較也會返回 true。
程序主方法先將第一個 Name 對象添加到 HashSet 中，該 Name 對象的 first 實例變量值爲"abc"，接着程序再次試圖將一個 first 爲"abc"的 Name 對象添加到 HashSet 中，很明顯，此時無法將新的 Name 對象添加到該 HashSet 中，由於此處試圖添加的 Name 對象的 first 也是" abc"，HashSet 會判斷此處新增的Name 對象與原有的 Name 對象相同，所以沒法添加進入，這時輸出 set 集合時將看到該集合裏只包含一個 Name 對象，就是第一個、last 爲"123"的 Name 對象。this