HashSet類の実現原理、特徴


HashSetは、ハッシュ・テーブルによってサポートされるSetインタフェースを実装する.setの反復順序を保証しません.特に、この順序が恒久的に変わらないことを保証しません.
 

  
  
  
  
  1. public class HashSet<E>    
  2.      extends AbstractSet<E>     
  3.      implements Set<E>, Cloneable, java.io.Serializable     
  4.  {    
  5.      static final long serialVersionUID = -5024744406713321676L;     
  6.     
  7.      //  HashMap HashSet 。     
  8.      private transient HashMap<E,Object> map;     
  9.          
  10.      //  Object HashMap value, static final。     
  11.      private static final Object PRESENT = new Object();     
  12.     
  13.      /**  
  14.        *  , HashSet。 
  15.        * 
  16.        *  HashMap, 16 0.75。 
  17.        */   
  18.      public HashSet() {     
  19.       map = new HashMap<E,Object>();     
  20.       }    
  21.     
  22.      /**  
  23.        *  collection set。 
  24.        * 
  25.        *  0.75  
  26.        * collection HashMap。 
  27.        * @param c  set collection。 
  28.        */   
  29.      public HashSet(Collection<? extends E> c) {     
  30.       map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 116));     
  31.       addAll(c);    
  32.       }    
  33.     
  34.      /**  
  35.        *  initialCapacity loadFactor HashSet。 
  36.        * 
  37.        *  HashMap。 
  38.        * @param initialCapacity  。 
  39.        * @param loadFactor  。 
  40.        */   
  41.      public HashSet(int initialCapacity, float loadFactor) {     
  42.       map = new HashMap<E,Object>(initialCapacity, loadFactor);     
  43.       }    
  44.     
  45.      /**  
  46.        *  initialCapacity HashSet。 
  47.        * 
  48.        *  loadFactor 0.75 HashMap。 
  49.        * @param initialCapacity  。 
  50.        */   
  51.      public HashSet(int initialCapacity) {     
  52.       map = new HashMap<E,Object>(initialCapacity);     
  53.       }    
  54.     
  55.      /**  
  56.        *  initialCapacity loadFactor 。 
  57.        *  , , LinkedHashSet 。 
  58.        * 
  59.        *  LinkedHashMap 。 
  60.        * @param initialCapacity  。 
  61.        * @param loadFactor  。 
  62.        * @param dummy  。 
  63.        */   
  64.       HashSet(int initialCapacity, float loadFactor, boolean dummy) {     
  65.       map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);     
  66.       }    
  67.     
  68.      /**  
  69.        *  set 。 。 
  70.        * 
  71.        *  HashMap keySet key。 
  72.        *  HashSet , HashMap key , 
  73.        * value static final Object 。 
  74.        * @return  set Iterator。 
  75.        */   
  76.      public Iterator<E> iterator() {     
  77.      return map.keySet().iterator();     
  78.       }    
  79.     
  80.      /**  
  81.        *  set (set )。 
  82.        * 
  83.        *  HashMap size() Entry , Set 。 
  84.        * @return  set (set )。 
  85.        */   
  86.      public int size() {     
  87.      return map.size();     
  88.       }    
  89.     
  90.      /**  
  91.        *  set , true。 
  92.        * 
  93.        *  HashMap isEmpty() HashSet 。 
  94.        * @return  set , true。 
  95.        */   
  96.      public boolean isEmpty() {     
  97.      return map.isEmpty();     
  98.       }    
  99.     
  100.      /**  
  101.        *  set , true。 
  102.        *  , set (o==null ? e==null : o.equals(e)) 
  103.        *  e , true。 
  104.        * 
  105.        *  HashMap containsKey key。 
  106.        * @param o  set 。 
  107.        * @return  set , true。 
  108.        */   
  109.      public boolean contains(Object o) {     
  110.      return map.containsKey(o);     
  111.       }    
  112.     
  113.      /**  
  114.        *  set , 。 
  115.        *  ,  set  (e==null ? e2==null : e.equals(e2)) 
  116.        *  e2, set  e。 
  117.        *  set , set false。 
  118.        * 
  119.        *  key HashMap。 
  120.        *  HashMap put() key-value , HashMap Entry key 
  121.        *  Entry key (hashCode() , equals true), 
  122.        *  Entry value Entry value, key , 
  123.        *  HashSet , HashMap , 
  124.        *  , Set 。 
  125.        * @param e  set 。 
  126.        * @return  set , true。 
  127.        */   
  128.      public boolean add(E e) {     
  129.      return map.put(e, PRESENT)==null;     
  130.       }    
  131.     
  132.      /**  
  133.        *  set , 。 
  134.        *  , set (o==null ? e==null : o.equals(e)) e, 
  135.        *  。 set , true 
  136.        * ( : set , true)。( , set )。 
  137.        * 
  138.        *  HashMap remove Entry。 
  139.        * @param o  set 。 
  140.        * @return  set , true。 
  141.        */   
  142.      public boolean remove(Object o) {     
  143.      return map.remove(o)==PRESENT;     
  144.       }    
  145.     
  146.      /**  
  147.        *  set 。 , set 。 
  148.        * 
  149.        *  HashMap clear Entry 。 
  150.        */   
  151.      public void clear() {     
  152.       map.clear();    
  153.       }    
  154.     
  155.      /**  
  156.        *  HashSet : 。 
  157.        * 
  158.        *  HashMap clone() , HashMap , HashSet 。 
  159.        */   
  160.      public Object clone() {     
  161.          try {     
  162.               HashSet<E> newSet = (HashSet<E>) super.clone();     
  163.               newSet.map = (HashMap<E, Object>) map.clone();    
  164.              return newSet;     
  165.           } catch (CloneNotSupportedException e) {     
  166.              throw new InternalError();     
  167.           }    
  168.       }    
  169.  }