Java 集合学习系列(二)： HashSet 的实现原理

1. HashSet 概述
HashSet 实现 Set 接口，由哈希表（其实是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类容许使用 null 元素。
2. HashSet 的实现
对于 HashSet 而言，它是基于 HashMap 实现的， HashSet 底层使用 HashMap 来保存全部元素，所以 HashSet 的实现比较简单，相关 HashSet 的操做，基本上都是直接调用底层HashMap 的相关方法来完成， HashSet 的源代码以下：
Java 代码

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 比较也返回 t
rue）， 
       * 新添加的 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 的浅表副本，并设置到 HashSe
t 中。 
       */  
      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 的实现原理，请参考个人上一遍总结：深刻 Java 集合学习系列：HashMap 的实现原理。
2) 对于 HashSet 中保存的对象，请注意正确重写其 equals 和 hashCode 方法，以保证放入的对象的惟一性。