關於TreeSet

java.lang.Object
  |_ java.util.AbstractCollection<E>
    |_ java.util.AbstractSet<E>
        |_java.util.TreeSet<E>
TreeSet類聲明如下：
public class TreeSet<E>
  extends AbstractSet<E>
  implements SortedSet<E>, Cloneable, java.io.Serializable
因爲實現了SortedSet類，所以具有自然排序的功能。
TreeSet和HashSet相同的地方，就是集合裏面不允許有重複的元素。自然排序情況下，一個TreeSet中只允許存放同一類型的多個元素，這裏要求不是自定義的類。例如：
Set treeSet = new TreeSet();
  treeSet.add(new String("aaa"));
  treeSet.add(new String("aaa"));
  treeSet.add(new String("bbb"));
  treeSet.add(new String("ccc"));
  treeSet.add(new String("aaa"));
  System.out.println(treeSet);
結果輸出爲：
[aaa, bbb, ccc]
這時，treeSet.size()=3。而且，它是經過排序的輸出。
如果有多個類的對象都加入到TreeSet集合中，就會發生異常。比如：
treeSet.add(new String("aaa"));
treeSet.add(new Integer(100));
System.out.println(treeSet);
發生異常：
Exception in thread "main" java.lang.ClassCastException: java.lang.String
at java.lang.Integer.compareTo(Integer.java:35)
at java.util.TreeMap.compare(TreeMap.java:1093)
at java.util.TreeMap.put(TreeMap.java:465)
at java.util.TreeSet.add(TreeSet.java:210)
at org.shirdrn.TreeSetTest.main(TreeSetTest.java:18)
而對於自定義的類，它的對象只能存放一個，而且實現類不需要實現Comparable接口。
但是，如果想要存放多個自定義的類的對象，不實現Comparable接口就會發生java.lang.ClassCastException異常。因此，想要能夠進行客戶化排序，必須實現比較器。
實現Comparable接口，就要實現compareTo()方法。而TreeSet又不存儲相同的元素，這就要求自定義的類重寫hashCode()和equals()方法：
class Person implements Comparable{
private String name;
private Integer age;
public Integer getAge() {
  return age;
}
public void setAge(Integer age) {
  this.age = age;
}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}

public boolean equals(Object o){
  if(this == o){
  return true;
  }
  if(! (o instanceof Person)){
  return false;
  }
  final Person other = (Person)o;
  if(this.name.equals(other.getName()) && this.age.equals(other.getAge())){
  return true;
  }
  else{
  return false;
  }
}

public int hashCode(){
  int result;
  result = (name == null?0:name.hashCode());
  result = 37*result + (age == null?0:age.hashCode());
  return result;
}
public int compareTo(Object o){
  Person other = (Person)o;
  if(this.name.compareTo(other.getName()) > 0){
  return 1;
  }
  if(this.name.compareTo(other.getName()) < 0){
  return -1;
  }
  if(this.getAge().intValue() > other.getAge().intValue()){
  return 1;
  }
  if(this.getAge().intValue() < other.getAge().intValue()){
  return -1;
  }
  return 0;
}

}
測試一下：
Set treeSet = new TreeSet();
  Person p1 = new Person();
  p1.setName("shirdrn");
  p1.setAge(new Integer(26));
  treeSet.add(p1);
  Person p2 = new Person();
  p2.setName("shirdrn");
  p2.setAge(new Integer(26));
  treeSet.add(p2);
  System.out.println(treeSet);
實例化了2個Person對象，實際上他們是同一個，因此只輸出一個：
[org.shirdrn.Person@c29b5984]
如果將p2的name設置爲p2.setName("Keller")，則輸出兩個：
[org.shirdrn.Person@5462263d, org.shirdrn.Person@c29b5984]
由於在Person類中實現類了compareTo()方法，輸出結果是排序的，首先按照name排序，然後再按照age排序：
while(it.hasNext()){
  Person p = (Person)it.next();
  System.out.println("name = "+p.getName()+" || age = "+p.getAge());
  }
輸出結果爲：
name = Keller || age = 26
name = shirdrn || age = 26
name按照字母序排序。如果name相同，就按照age數字序排序。
TreeSet具有一些和HashSet類似的方法。

TreeSet的主要性質

1、TreeSet中不能有重複的元素；

2、TreeSet具有排序功能；

3、TreeSet中的元素必須實現Comparable接口並重寫compareTo()方法，TreeSet判斷元素是否重複 、以及確定元素的順序 靠的都是這個方法；(這條性質比較重要，如果對TreeSet內部機制比較熟悉的話這條性質應該不難理解；如果讀者不太理解的話可以參看以下這篇文章http://wlh269.iteye.com/blog/376430 )

4、對於java類庫中定義的類，TreeSet可以直接對其進行存儲，如String，Integer等(因爲這些類已經實現了Comparable接口)；

5、對於自定義類，如果不做適當的處理，TreeSet中只能存儲一個該類型的對象實例，請看程序示例:

import java.util.*;
public class TreeSetDemo{
 public static void main(String args[]){
  TreeSet<Demo> tSet=new TreeSet<Demo>();
  Demo d1=new Demo(1,"abc");
  Demo d2=new Demo(2,"xyz");

  tSet.add(d1);
  tSet.add(d2);//如果有這條語句，運行程序時會拋出ClassCastException異常
                       //如果沒有這條語句，程序會正常運行，並輸出d1的內容
  Iterator itr=tSet.iterator();
  while(itr.hasNext()){
   Demo d=(Demo)itr.next();
   System.out.print(d.a+" "+d.b);
   System.out.println();
  }
 } 
}
class Demo{
 int a;
 String b;
 public Demo(int a,String b){
  this.a=a;
  this.b=b;
 }
}

在TreeSet中存儲自定義的類的實現方法

示例:

import java.util.*;
public class TreeSetDemo{
 public static void main(String args[]){
  TreeSet<Demo> tSet=new TreeSet<Demo>();
  Demo d2=new Demo(2,"xyz");
  Demo d3=new Demo(2,"uvw");

  Demo d1=new Demo(1,"abc");

  tSet.add(d1);
  tSet.add(d2);
  tSet.add(d3);

  Iterator itr=tSet.iterator();
  while(itr.hasNext()){
   Demo d=(Demo)itr.next();
   System.out.print(d.a+" "+d.b);//注意此程序運行時會輸出幾個元素
   System.out.println();
  }
 } 
}
class Demo implements Comparable{
 int a;
 String b;
 public Demo(int a,String b){
  this.a=a;
  this.b=b;
 }
  public int compareTo(Object o){
   Demo demo=(Demo)o;
  if(this.a>demo.a){
   return 1;
  }else if(this.a<demo.a){
   return -1;
  }else{
   return 0;
  }
 }
}

解析:上面程序會輸出兩個元素，並且是以a爲判斷標準按序輸出的。當調用TreeSet的add()方法時，在TreeSet的內部會間接調用Demo的compareTo()方法、然後和TreeSet中已經存在的其他元素一一進行比較，在比較的過程中完成“判斷是否重複”以及“排序”的功能:當在某次比較的過程中發現compareTo()返回0，就會認爲待加入的元素已經存在於TreeSet中，返回-1或1的話就會根據TreeSet默認的比較器進行排序。

下面對程序進行修改，重寫compareTo()方法，讓TreeSet以a和b兩個屬性爲依據來判斷元素是否重複以及元素的順序，請看下面的示例:

import java.util.*;
public class TreeSetDemo{
 public static void main(String args[]){
  TreeSet<Demo> tSet=new TreeSet<Demo>();
  Demo d1=new Demo(1,"abc");
  Demo d2=new Demo(2,"xyz");
  Demo d3=new Demo(2,"uvw");

  tSet.add(d1);
  tSet.add(d2);
  tSet.add(d3);

  Iterator itr=tSet.iterator();
  while(itr.hasNext()){
   Demo d=(Demo)itr.next();
   System.out.print(d.a+" "+d.b);//注意這次輸出的元素個數
   System.out.println();
  }
 } 
}
class Demo implements Comparable{
 int a;
 String b;
 public Demo(int a,String b){
  this.a=a;
  this.b=b;
 }
  public int compareTo(Object o){
   Demo demo=(Demo)o;
if(this.a==demo.a&&this.b.equals(demo.b)){
   return 0;
  }else if(this.a>demo.a){
   return 1;
  }else {
   return -1;
  }
 }
}

解析:這次改動了compareTo()方法，程序輸出了三個元素d1，d2和d3；當我們自己定義類，並且需要將自定義的類存到TreeSet中的時候，需要認真考慮compareTo的定義方式即需要認真考慮實際應用中依據什麼判斷元素是否重複和元素的順序。