Java-TreeSet的使用

TreeSet是通过红黑二叉树的结构对那些可“排序”的对象进行存放的。

TreeSet:排序的功能,利用二叉数(红黑树)进行排序的.它是根据比较器返回的值来确定顺序的,
 *   如果返回值是正数则大,负数表示小,0表示相等.所以放进TreeSet集合里的数据要么
 *   实现Comparable接口,让数据本身具有比较性.或者让容器有比较性。

TreeSet根据比较器判断是否重复和进行排序.如果容器和数据都具有比较性,则优先使用容器的比较器.
 * 1:对象具有比较性,让对象所属的类实现Comparable接口,重写compareTo方法.
 * 2:容器(TreeSet)比较比较性,可以写一个类实现Comparator接口,重写compareTo方法,将这个类的对象传给容器的构造方法

TreeSet可以用在排序方面如： 

/*1.TreeSet练习
人类，属性姓名，收入，年龄，书，
书类：属性书名，价格
存储TreeSet<Person>集合，排序规则：
A：先按照收入排序：从高到低
B：收入相等的情况下，按照年龄排序：从小大大
C：如果收入和年龄都相等，按照姓名排序，字典顺序（String类的compareTo方法）
D：如果以上3个属性都相等，按照书排序，先按照书价格：从低到高，如果书价格相等，按照书名（字典顺序）。
2.利用自定义比较器完成上题。（使用匿名内部类）*/
import java.util.*;
import java.util.TreeSet;
import java.util.Comparator ;
import java.util.Iterator;
public class Test
{
       public static void main (String []args)
      {
         TreeSet<Person> ts=new TreeSet<Person>(new Mycomparator());
        
         ts.add(new Person("g",42,1800,new Literature("book-b",34)));
         ts.add(new Person("a",33,1700,new Literature("book-b",44)));
         ts.add(new Person("a",39,1700,new Literature("book-b",24)));
         ts.add(new Person("d",33,1300,new Literature("book-d",14)));
         ts.add(new Person("c",33,1300,new Literature("book-s",60)));
         ts.add(new Person("c",33,1300,new Literature("book-f",90)));
         ts.add(new Person("c",33,1300,new Literature("book-g",90)));
          ts.add(new Person("a",44,20000,new Literature("book-a",64)));
         Iterator<Person> it=ts.iterator();
         while(it.hasNext())
          {
           System.out.println(it.next());
          }
       
      }
}
//定义一个比较器，
class  Mycomparator implements Comparator<Person>
{
//A：先按照收入排序：从高到低
//B：收入相等的情况下，按照年龄排序：从小大大
//C：如果收入和年龄都相等，按照姓名排序，字典顺序（String类的compareTo方法）
//D：如果以上3个属性都相等，按照书排序，先按照书价格：从低到高，如果书价格相等，按照书名（字典顺序）。
//思路：这种情况应该用if-else实现分支对应不同情况
    public int compare (Person p1,Person p2)
    {   
       if(p1.sal!=p2.sal)
        return p2.sal-p1.sal;
       else if(p2.age!=p1.age)
           return p1.age-p2.age;
           else if(! p1.name.equals(p2.name))
                 return  p1.name.compareTo(p2.name);
                else if(p1.lt.price!=p2.lt.price)
                      return p1.lt.price-p2.lt.price;
                      else 
                        return p1.lt.bookname.compareTo(p2.lt.bookname);
        // return 0;
    }
}
class Person
{
      String name;
      int age;
      int sal;
      Literature lt;
    public String toString ()
    {
      return this.name+" 人士,收入："+this.sal+"元,年龄："+this.age+" 岁,书价格："+this.lt.price+"元,书名："+this.lt.bookname ;
    }
    public Person (String name, int age, int sal,Literature lt)
    {
      this.name=name;
      this.age=age;
      this.sal=sal ;
      this.lt=lt;
    }
    public Person ()
    {
    }
}
class Literature
{
    String bookname;
    int price;
    public Literature(String bookname ,int price)
    {
      this.bookname=bookname;
      this.price=price;
    }
}

 

容器具有比较性。

TreeSet提供了一个构造方法用于用指定的comparator比较器去比较那些可“排序”的对象，直接匿名comparetor，或者用一个类去实现继承它。

/*
 * 对字符串进行长度排序
 * aa a  bbb cccd  ddddt eeeeee
 * a aa bbb cccd  ddddt  eeeeee
 *
 */
 import java.util.TreeSet;
 import java.util.Iterator;
 import java.util.*;
 public class Demo4
 {
     public static void main (String []args)
     {
       TreeSet<String> tset=new TreeSet<String >(new Comparator<String>(){
         public int compare(String str1,String str2)
           {
              return str1.length()-str2.length();
            }
       } );
       tset.add("aaaa");
       tset.add("a");
       tset.add("aaaaaaaa");
       Iterator it=tset.iterator();
       while(it.hasNext())
         {
            System.out.println(it.next());
         }
    }
 }

//
//让类(比较器)去实习Comparator接口，再新建TreeSet时向构造方法传入这个比较器。
//
import java.util.TreeSet;
import java.util.Iterator;
import java.util.Comparator;
public class Demo5
{
    public static void main (String []args)
    {
       TreeSet<String> ts=new TreeSet<String> (new MyComparator());
       ts.add("aaaaaa");
       ts.add("bbb");
       ts.add("cccccccc");
       Iterator<String> it=ts.iterator();
       while(it.hasNext())
        {
          System.out.println(it.next());
        }
    }
}
class MyComparator implements Comparator<String>
{
    public int compare(String str1,String str2)
    {
       return str1.length()-str2.length(); 
     
    }

}

数据具有比较性。

对那些可“排序”的类，先进行排序，在存放入TreeSet里
  //狗比较比较性,实现Comparable接口.重写compareTo这个方法.

 public class Dog implements Comparable<Dog> {

@Override
 public boolean equals(Object obj) {
  Dog dog = (Dog)obj;
  if(dog.getAge()==this.getAge() && dog.getKind().equals(this.getKind()) && dog.getName().equals(this.getName()))
  return true;
  else
   return false;
 }

@Override
 public int compareTo(Dog o) {
  // TODO Auto-generated method stub
  //年龄  如果当前对象的年龄比传进来的对象的年龄大,则返回正数.小则返回负数,否则返回0
  if(this.getAge()>o.getAge()){
   return 1;
  }else if(this.getAge()==o.getAge()){
   return 0;
  }else
  return -1;
 }

}