자바 HashSet 의 실현 원리

1.    HashSet 개요:
   HashSet 은 Set 인 터 페 이 스 를 실현 하고 해시 표 (실제 HashMap 인 스 턴 스) 가 지원 합 니 다.set 의 교체 순 서 를 보장 하지 않 습 니 다.특히 이 순서 가 영원히 변 하지 않 는 다 는 것 은 보장 되 지 않 는 다.null 요 소 를 사용 할 수 있 습 니 다.
2.    HashSet 의 실현:
   HashSet 의 경우 HashMap 을 바탕 으로 이 루어 진 것 입 니 다. HashSet 바 텀 은 HashMap 을 사용 하여 모든 요 소 를 저장 하기 때문에 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. 관련 설명:
   1) HashMap 의 실현 원리 에 대해 서 는 지난 번 의 정 리 를 참고 하 시기 바 랍 니 다.
자바 HashMap 의 실현 원리.
   2) HashSet 에 저 장 된 대상 에 대해 서 는 equals 와 hashCode 방법 을 정확하게 재 작성 하여 넣 은 대상 의 유일 성 을 확보 하 십시오.
참고:http://zhangshixi.iteye.com/blog/673143