关于TreeSet的排序问题

在 大多数的java项目中，我们都会用到Java的集合,如 Collection和Map接口。其中用到它们最多的实现类一般要数HashSet,ArrayList,HashMap, 对于 TreeSet,LinkList,TreeMa p这 些类一般人可能会相对用得少了.其实这些实现类还是非常有用的。这里 阿堂就和您一起去探个究 经吧，看看它们是 何方神圣!
　　　TreeSet是SortedSet接口的唯一实现，TreeSet可以确保集合元素处于排序状态.TreeSet提供了一些额外的方法
Comparator comparator() :返回当前Set使用的Comparator, 或者返回null,表示以自然方式排序.
Object first() :返回集合中的第一个元素.
Object last() :返回集合中最末一个元素.
SortedSet headSEt(toElement): 返回此Set的子集，由小于toElement的元素组成.
SortedSet tailSet(fromElement): 返回此Set的子集，由大于或等于fromElement的元素组成.
SortedSet subSet(fromElement,toElement): 返回此Set的子集合，范围由fromElement( 包含)到toElement(不包含).
特别强调一点:
Treeset中的元素是有序的.

下面我们来看一个TreeSet的通知方法
import java.util.*;
public class TestTreeSetCommon
{
       public static void main(String[] ar gs)
       {
              TreeSet nums = new TreeSet();
              //向TreeSet中添 加四个Integer对象
              nums.add(5);
              nums.add(2);
              nums.add(10);
              nums.add(-9);
              //输出集合元素，看到集合元素已经处于排序状态
              System.out.println(nums);
              //输出集合里的第一个元素
              System.out.println(nums.first());
              //输出集合里的最后一个元素
              System. out.println(nums.last());
              //返回小于4的子集，不包含4
              System.out.println(nums.headSet(4));
              //返回大于5的子集，如果Set中包含5，子集中还包含5
              System.out.println(nums.tailSet(5));
              //返回大于等于-3，小于4的子集。
              System.out.println(nums.subSet(-3 , 4));
       }
}





根据上述结果，我们不难看出:TreeSet并不 是根据元素的插入顺 序来排序的，而是根据元素 的实际值来排序的.
特别说明
(1)与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构对元素进行排序。
(2)TreeSet支持两种排序方法:自然排序和定制排序
(3)红黑树是一个更高效的检索二叉树，因此常常用来实现关联 数组。典型地，JDK提供的集合类TreeMap本身就是一个红黑树的实现.
(4)对于TreeSet集合而言，它判断两个对象不相等的标准是:两个对象通过equals方法比较返回false，或通过compareTo(Object obj)比较没有返回0(即使两个 对象是同一个对象)

TreeSet支持的两种排序方式
(1)自然排序
TreeSet会调用集合元素的compareTo(Object obj)方法来比较两个元素之间的大小关系，然后将集合元素按升序排列，这种方式就是自然排序.
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小.

import java.util.*;
class R implements Comparable
{
       int count;
       public R(int count)
       {
              this.count = count;
       }
       pu blic String toString()
       {
              return "R(count属性:" + count + ")" ;
       }
       public boolean equals(Objec t obj)
       {
              if (obj instanceof R)
              {
                     R r = (R)obj;
                     if (r.co u nt == this.count)
                     {
                            return true;
                     }
              }
              return false;
       }
       pub lic  int compareTo(Object ob j)
       {
              R r = (R)obj;
              if (this .co unt > r .count)
              {
                     return 1;
              }
              else if (this.count == r.count)
              {
                     return 0;
              }
              else
              {
                     return -1;
              }
       }
}
public c lass TestTreeSet2
{
       public static void main(String[] args)
       {
              TreeSet ts = new TreeSet();
              ts.add(new R(5));
              ts.add(new R(-3));
              ts.add(new R(9));
              ts.add(new R(-2));
              //打印TreeSet集合，集合元素是有序排列的
              System.out.println(ts);
              //取出第一个元素
              R firs t = (R)ts.first();
              //为第一个元素的count属性赋值
              first.count = 20;
              //取出最后一个元素
              R last = (R)ts.last();
              //为最后一个元素的count属 性赋值，与倒数第二个元素count属性相同
              last.count = -2;
              //再次输出count将看到TreeSet 里的元素处于无序状态，且有重复元素
              System. out.println(ts);
              //删除属性被改变的元素，删除失败
              ts.remove(new R(-2));
              System.out.println(ts);
              //删除属性没有改变的元素，删除成 功
              ts.remove(new R(5));
              Sy stem.out.println(ts);
       }
}




注意 ：
当 需要把一个对象放入一个TreeSet中时，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果人， 其规则是:如果两个 对象通过equals方法比较 返回true时，这两个对象通过compareTo(object obj)方法应返回0.


(2)定制排序
TreeSet的自然排 序是根据集合元素的大小，TreeSet将它 们以升序排列。如果需要实现定制排序，例如以降序排列，则可以使用 Comparator接口的帮助.
该接口里包含一个int compare(T o1,T o2)方法，该方法用于比较o1和o2的大小：如果该方法返回正整数，则表明o1大于o2;如果该方法返回0,则表明o1等于o2;如果该方法返回负整数，则表明o1小于o2.

下面的逻辑刚好相反，就实现了降序

import java.util.*;
class M
{
       int age;
       public M(int age)
       {
              this.age = age;
       }
       public String toString(){
              return "M对象(age:"+ age +")";
       }
}
public class TestTreeSet3
{
       public static void main(String[] args)
       {
              TreeSet ts = new TreeSet(new Comparato r()
              {
                     public int compare(Object o1, Object o2)
                     {

                            M m1 = (M)o1;
                            M m2 = (M)o2;

                            if (m1.age > m2.age)
                            {
                                   return -1;
                            }
                            else if (m1.age == m2.age)
                            {
                                   return 0;
                            }
                            else
                            {
                                   return 1;
                            }
                     }
              });     
              ts.add(new M(5));
              ts.add(new M(-3));
              ts.add(new M(9));
              System.out.println(ts);
       }
}

转自：http://blog.sina.com.cn/s/blog_4c925dca0100qh2d.html

时空网络的博客