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接口，就不细说了,可能有些说得不对的地方，欢迎指正