java数据结构-set_java set数据结构

看一段set的简单应用代码

        Set<String> set = new HashSet<String>();
         String a = "1",b = "2",c = "1",d = "3",e = "2";
         set.add(a);
         set.add(b);
         set.add(c);
         set.add(d);
         set.add(e);
         
         Iterator it = set.iterator();
         while(it.hasNext()){
             String s = (String)it.next();
             System.out.print(s+",");
         }
         System.out.println("一共有对象："+set.size()+"个"); //打印结果是：3,2,1,一共有对象：3个

我们都知道Set是一种最简单的集合，对象的排序无特定的规则，集合里面存放的是对象的引用，所以没有重复的对象，在上面的代码中，程序创建了a、b、c、d、e五个变量，其中a和c，b和e所引用的字符串是一致的，然后向set添加了这5个变量。打印出来的size()只有3个，实际上向集合加入的只有3个对象，在执行Set的add()方法时已经进行了判断这个对象是否存在于集合，如果对象已经存在则不继续执行。

Set的接口有两个实现类，HashSet和TreeSet，HashSet是按照哈希算法来进行存取集合中的对象，存取速度比较快，TreeSet类显示了SortedSet接口，具有排序功能

HashSet
HashSet是按照哈希算法来存取集合中的对象，具有很好的存取和查找性能，当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获取哈希码，然后根据这个哈希吗来计算对象在集合中的存放位置。
在Object类中定义了hashCode()和equal()，equal()是按照内存地址比较对象是否相同，如果object1.equal(object1)w为true时，则表明了object1和object2变量实际上引用了同一个对象，那么object1和object2的哈希码也是肯定相同。
稍微的看看HashSet的源码

public class HashSet<E>
     extends AbstractSet<E>
     implements Set<E>, Cloneable, java.io.Serializable
 {
 
     private transient HashMap<E,Object> map;
     private static final Object PRESENT = new Object();
         public HashSet() {
         map = new HashMap<E,Object>();
     }
 
     public boolean add(E e) {
         return map.put(e, PRESENT)==null;
     }
 }

public class HashMap<K,V>
     extends AbstractMap<K,V>
     implements Map<K,V>, Cloneable, Serializable
 {
 
     public V put(K key, V value) {
         if (key == null)
             return putForNullKey(value);
         int hash = hash(key.hashCode());
         int i = indexFor(hash, table.length);
         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
             Object k;
             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                 V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
             }
         }
 
         modCount++;
         addEntry(hash, key, value, i);
         return null;
     }
 
 }

我们会发现我们调用Set的add()方法其实是返回一个transient HashMap.put(e, PRESENT)，再跟进HashMap的put(K key, V value)方法进行查看,可以看到int hash = hash(key.hashCode());使用了set.add(key)的key做了一个哈希处理得到一个哈希码，然后再将Entry做了一个遍历，使用equal()方法对讲原有的对象和新添加的对象进行了一个比较，如果出现了true的情况，就直接返回一个oldValue，如果在遍历对比的过程中没有出现ture的情况，则继续一下的步骤modCount++，将对象总数自加，并且继续执行addEntry()的操作，下面涉及HashMap的操作就不继续。

实际上HashSet的底层实现是基于HashMap，所以在此处涉及到Hash算法不展开，详细可以见另一篇《java数据结构-HashMap》

TreeSet
TreeSet类是实现了SortedSet接口，所以能够对集合中的对象进行排序

Set iset = new TreeSet();
         iset.add(new Integer(1));
         iset.add(new Integer(10));
         iset.add(new Integer(5));
         iset.add(new Integer(8));
         iset.add("2");
         Iterator it2 = iset.iterator();
         while(it2.hasNext()){
             Integer s = (Integer)it2.next();
             System.out.print(s+",");
         }
         System.out.println("一共有对象："+iset.size()+"个");//打印出来的结果：1,2,5,8,10,一共有对象：5个

当TreeSet向集合加入一个对象时，会把它插入到有序的对象序列中，TreeSet包括了两种排序方式，自然排序和客户化排序，在默认的情况下使用自然排序。

自然排序
在jdk类库中，有部分类实现了Comparable接口，如Integer，Double等等，Comparable接口有一个compareTo()方法可以进行比较，TreeSet调用对象的compareTo()方法比较集合中对象的大小，然后进行升序排序。如Integer：

public final class Integer extends Number implements Comparable<Integer> {
 
     public int compareTo(Integer anotherInteger) {
     int thisVal = this.value;
     int anotherVal = anotherInteger.value;
     return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
     }
 
 }

基于Comparable的属性，使用自然排序时，只能向TreeSet集合中加入同类型的对象，并且这些对象的类必须实现了Comparable的接口，以下我们尝试向TreeSet集合加入两个不同类型的对象，会发现抛出ClassCastException

Set iset = new TreeSet();
 iset.add(new Integer(1));
 iset.add(new Integer(8));
 iset.add("2");
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer

我们再打开TreeSet的源码进行查看

public class TreeSet<E> extends AbstractSet<E>
     implements NavigableSet<E>, Cloneable, java.io.Serializable
 {
     private transient NavigableMap<E,Object> m;
 
     private static final Object PRESENT = new Object();
 
     public boolean add(E e) {
     return m.put(e, PRESENT)==null;
     }
 
 }

NavigableMap为接口，实现类为TreeMap

public class TreeMap<K,V>
     extends AbstractMap<K,V>
     implements NavigableMap<K,V>, Cloneable, java.io.Serializable
 {
     private final Comparator<? super K> comparator;
 
     private transient Entry<K,V> root = null;
 
     public V put(K key, V value) {
         Entry<K,V> t = root;
         if (t == null) {
         // TBD:
         // 5045147: (coll) Adding null to an empty TreeSet should
         // throw NullPointerException
         //
         // compare(key, key); // type check
            root = new Entry<K,V>(key, value, null);
             size = 1;
             modCount++;
             return null;
         }
         int cmp;
         Entry<K,V> parent;
         // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
         if (cpr != null) {
             do {
                 parent = t;
                 cmp = cpr.compare(key, t.key); //此处如果类别不相同可能抛出ClassCastException
                if (cmp < 0)
                     t = t.left;
                 else if (cmp > 0)
                     t = t.right;
                 else
                     return t.setValue(value);
             } while (t != null);
         }
         else {
             if (key == null)
                 throw new NullPointerException();
             Comparable<? super K> k = (Comparable<? super K>) key;
             do {
                 parent = t;
                 cmp = k.compareTo(t.key);
                 if (cmp < 0)
                     t = t.left;
                 else if (cmp > 0)
                     t = t.right;
                 else
                     return t.setValue(value);
             } while (t != null);
         }
         Entry<K,V> e = new Entry<K,V>(key, value, parent);
         if (cmp < 0)
             parent.left = e;
         else
             parent.right = e;
         fixAfterInsertion(e);
         size++;
         modCount++;
         return null;
     }
 
 }

首先判断原始集合是否存在，如果不存在则直接创建，无需比较。
如果原始集合存在的话，先去取出Comparator对象，然后遍历原始集合t，使用parent为临时比较值，逐个使用compare(key, t.key)方法与添加对象key进行比较，决定元素排在集合的left或right。

客户端排序
客户端排序时因为java.util.Comparator<Type>接口提供了具体的排序方式，<Type>指定了被比较对象的类型，Comparator有个compare(Type x,Type y)的方法，用于比较两个对象的大小。

public class NameComparator implements Comparator<Name>{
     
     public int compare(Name n1,Name n2){
         if(n1.getName().compareTo(n2.getName())>0) return -1;
         if(n1.getName().compareTo(n2.getName())<0) return 1;
         
         return 0;
     }
     
     public static void main(String[] args) {
         Set<Name> set = new TreeSet<Name>(new NameComparator());
         
         Name n1 = new Name("ray");
         Name n2 = new Name("tom");
         Name n3 = new Name("jame");
         set.add(n1);
         set.add(n2);
         set.add(n3);
         
         Iterator it = set.iterator();
         while(it.hasNext()){
             Name s = (Name)it.next();
             System.out.print(s.getName()+",");
         }
         System.out.println("一共有对象："+set.size()+"个");
     }
 }//打印结果是：tom,ray,jame,一共有对象：3个

道理与自然排序其实相同，都是通过实现Comparator接口，就不细说了,可能有些说得不对的地方，欢迎指正