Set 不重复实现原理

Java中的set是一个不包含重复元素的集合,确切地说,是不包含e1.equals(e2)的元素对。Set中允许添加null。Set不能保证集合里元素的顺序。

在往set中添加元素时,如果指定元素不存在,则添加成功。也就是说,如果set中不存在(e==null ? e1==null : e.queals(e1))的元素e1,则e1能添加到set中。

下面以set的一个实现类HashSet为例,简单介绍一下set不重复实现的原理:

[java]  view plain  copy
  1. import java.util.HashSet;  
  2. import java.util.Iterator;  
  3. import java.util.Set;  
  4.    
  5. /** 
  6. * @version 1.0 
  7. * @author Oliver 
  8. * @since 1.0 
  9. */  
  10. publicclass HashSetTest  
  11. {  
  12.     //自定义MyString类  
  13.     staticclass MyString{  
  14.         String value;  
  15.    
  16.         public MyString(String value)  
  17.         {  
  18.             this.value = value;  
  19.         }  
  20.     }  
  21.     publicstaticvoid main(String[] args)  
  22.     {  
  23.         //创建一个HashSet对象  
  24.         Set set = new HashSet();  
  25.         //创建连个String对象  
  26.         String s1 = new String("a");  
  27.         String s2 = new String("a");  
  28.         //创建连个MyString对象  
  29.         MyString s3 = new MyString("a");  
  30.         MyString s4 = new MyString("a");  
  31.         //添加元素  
  32.         set.add(s1);  
  33.         set.add(s2);  
  34.         set.add(s3);  
  35.         set.add(s4);  
  36.         //看看对象的equals  
  37.         System.out.println("s1.equals(s2):"+s1.equals(s2));  
  38.         System.out.println("s3.equals(s4):"+s3.equals(s4));  
  39.         //打印几个大小及里面的元素  
  40.         System.out.println("set size:"+set.size());  
  41.         for(Iterator it=set.iterator();it.hasNext();){  
  42.             System.out.println(it.next());  
  43.         }  
  44.     }  
  45. }  

  46. 运行程序,输出结果:

    s1.equals(s2):true

    s3.equals(s4):false

    set size:3

    oliver.examination.part1.HashSetTest$MyString@4f1d0d

    a

    oliver.examination.part1.HashSetTest$MyString@1fc4bec

    也许你已经看出关键来了,没错就是equals方法。这么说还是不恰当,准确的说应该是equals和hashcode方法。

    java.lnag.Object中对hashCode的约定:

    1. 在一个应用程序执行期间,如果一个对象的equals方法做比较所用到的信息没有被修改的话,则对该对象调用hashCode方法多次,它必须始终如一地返回同一个整数。

    2. 如果两个对象根据equals(Object o)方法是相等的,则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。

    3. 如果两个对象根据equals(Object o)方法是不相等的,则调用这两个对象中任一个对象的hashCode方法,不要求产生不同的整数结果。但如果能不同,则可能提高散列表的性能。

    根据第一条,s1和s2返回的hashcode值是一样的。

    在HashSet中,基本的操作都是有HashMap底层实现的,因为HashSet底层是用HashMap存储数据的。当向HashSet中添加元素的时候,首先计算元素的hashcode值,然后用这个(元素的hashcode)%(HashMap集合的大小)+1计算出这个元素的存储位置,如果这个位置位空,就将元素添加进去;如果不为空,则用equals方法比较元素是否相等,相等就不添加,否则找一个空位添加。

    会后,附赠HashSet源码中文注释版,摘自javaeye:http://xifangyuhui.javaeye.com/blog/798796

    [java]  view plain  copy
    1. public class HashSet    
    2.     extends AbstractSet    
    3.     implements Set, Cloneable, java.io.Serializable    
    4. {    
    5.     static final long serialVersionUID = -5024744406713321676L;    
    6.     
    7.     // 底层使用HashMap来保存HashSet中所有元素。    
    8.     private transient HashMap 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();    
    20.     }    
    21.     
    22.     /**  
    23.      * 构造一个包含指定collection中的元素的新set。  
    24.      *  
    25.      * 实际底层使用默认的加载因子0.75和足以包含指定  
    26.      * collection中所有元素的初始容量来创建一个HashMap。  
    27.      * @param c 其中的元素将存放在此set中的collection。  
    28.      */    
    29.     public HashSet(Collectionextends E> c) {    
    30.     map = new HashMap(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(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(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(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 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.      *   

    你可能感兴趣的:(java)