java中treeset的降序用法_关于TreeSet倒序排列和自定义排列

1.TreeSet的自然排序.

TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法

Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序).

TreeSet中的元素将按照升序排列，缺省是按照自然排序进行排列，意味着TreeSet中的元素要实现Comparable接口。

如果要想使集合中的顺序按照降序排列的话需要用到TreeSet的descendingSet()方法.

1 package cn.summerchill.test;

2

3 import java.util.Iterator;

4 import java.util.TreeSet;

5

6 public class TreeSetDemo {

7 public static void main(String[] args) {

8 //String类型降序

9 // creating a TreeSet

10 TreeSet treeStr = new TreeSet();

11 TreeSet treeReverseStr= new TreeSet();

12 // adding in the tree set

13 treeStr.add("1");

14 treeStr.add("13");

15 treeStr.add("17");

16 treeStr.add("2");

17 // creating reverse set

18 treeReverseStr = (TreeSet) treeStr.descendingSet();

19 // create descending set

20 Iterator iteratorStr;

21 iteratorStr = treeReverseStr.iterator();

22 // displaying the Tree set data

23 System.out.println("Tree set data in reverse order for String type: ");

24 while (iteratorStr.hasNext()) {

25 System.out.println(iteratorStr.next() + " ");

26 }

27

28

29 //Integer类型降序

30 TreeSet tree = new TreeSet();

31 TreeSet treeReverse = new TreeSet();

32 tree.add(1);

33 tree.add(13);

34 tree.add(17);

35 tree.add(2);

36 // creating reverse set

37 treeReverse = (TreeSet) tree.descendingSet();

38 // create descending set

39 Iterator iterator2;

40 iterator2 = treeReverse.iterator();

41 // displaying the Tree set data

42 System.out.println("Tree set data in reverse order for Integer type: ");

43 while (iterator2.hasNext()) {

44 System.out.println(iterator2.next() + " ");

45 }

46 }

47 }

打印输出:

Tree set data in reverse order for String type:

2

17

13

1

Tree set data in reverse order for Integer type:

17

13

2

1

如果存数据的集合是ArrayList或者是Linkedlist他会是原样输出，如果是一个HashSet会乱序输出，但现在TreeSet会按顺序输出。

但是如果是一个自定义的类对象输出会出现异常:

示例代码:

1 import java.util.TreeSet;

2

3 public class TreeSetTest2 {

4 public static void main(String[] args) {

5 TreeSet tree= new TreeSet();

6 tree.add(new Person("zhangran"));

7 tree.add(new Person("zhang"));

8 System.out.println(tree);

9 }

10 }

11 class Person

12 {

13 String name;

14 Person(String name)

15 {

16 this.name = name;

17

18 }

19 public String toString()

20 {

21 return this.name;

22 }

23 }

运行输出:

Exception in thread "main" java.lang.ClassCastException: cn.summerchill.test.Person cannot be cast to java.lang.Comparable

at java.util.TreeMap.compare(Unknown Source)

at java.util.TreeMap.put(Unknown Source)

at java.util.TreeSet.add(Unknown Source)

at cn.summerchill.test.TreeSetTest2.main(TreeSetTest2.java:8)

此时此时便会出现异常，问题在于，TreeSet本来是应该比较大小，然后按顺序输出的但是，但是现在你给了他一个自己定义的类，它便无法识别，不知道怎么排序了，所以你现在所做的就是告诉他如何排序，此时就需要一个比较器.

TreeSet的两种排序方式

(1). 让元素本身具有比较性

元素本身要实现Comparable接口并实现里面的compareTo方法以保证元素本身具有比较性

(2). 让容器自身具有比较性

当元素本身不具有比较性或者具备的比较性不是所需要的，就在TreeSet建立实例的时候，传入Comparator接口的实现子类的实例。这个Comparator子类必须实现compare方法。

以下第2和第3条是这两种方式的实现.

2.TreeSet自定义类对象的排序

* 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口

*   在类上implement Comparable

*   重写compareTo()方法

*   在方法内定义比较算法, 根据大小关系, 返回正数负数或零

*   在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储

如果我们自己定义的一个类的对象要加入到TreeSet当中，那么这个类必须要实现Comparable接口。

1 import java.util.Iterator;

2 import java.util.Set;

3 import java.util.TreeSet;

4

5 public class Test_treeset {

6 public static void main(String[] args) {

7 Set ts = new TreeSet();

8 ts.add(new Teacher("zhangsan", 1));

9 ts.add(new Teacher("lisi", 2));

10 ts.add(new Teacher("wangmazi", 3));

11 ts.add(new Teacher("wangwu",4));

12 ts.add(new Teacher("mazi", 3));

13 Iterator it = ts.iterator();

14 while (it.hasNext()) {

15 System.out.println(it.next());

16 }

17 }

18 }

19 class Teacher implements Comparable {

20 int num;

21 String name;

22

23 Teacher(String name, int num) {

24 this.num = num;

25 this.name = name;

26 }

27

28 public String toString() {

29 return "学号：" + num + "\t\t姓名：" + name;

30 }

31

32 //o中存放时的红黑二叉树中的节点，从根节点开始比较

33 public int compareTo(Object o) {

34 Teacher ss = (Teacher) o;

35 //int result = num < ss.num ? 1 : (num == ss.num ? 0 : -1);//降序

36 int result = num > ss.num ? 1 : (num == ss.num ? 0 : -1);//升序

37 if (result == 0) {

38 result = name.compareTo(ss.name);

39 }

40 return result;

41 }

42 }

打印输出:

学号：1 姓名：zhangsan

学号：2 姓名：lisi

学号：3 姓名：mazi

学号：3 姓名：wangmazi

学号：4 姓名：wangwu

3.使用比较器(Comparator)对加入的数据进行排序

在使用Arrays对数组中的元素进行排序的时候，可以传递一个比较器。

在使用Collections对集合中的元素进行排序的时候，可以传递一个比较器。

那么在使用TreeSet对加入到其中的元素进行排序的时候可以传入一个比较器吗？

1 public TreeSet(Comparator super E> comparator) {

2 this(new TreeMap(comparator));

3 }

通过查看它的构造方法就知道可以传入一个比较器。

构造一个新的空TreeSet，它根据指定比较器进行排序。插入到该 set 的所有元素都必须能够由指定比较器进行相互比较：对于 set 中的任意两个元素 e1 和e2，执行 comparator.compare(e1, e2) 都不得抛出 ClassCastException。如果用户试图将违反此约束的元素添加到 set 中，则 add 调用将抛出 ClassCastException。

1 import java.util.Comparator;

2 import java.util.Iterator;

3 import java.util.TreeSet;

4

5 public class TreeSetTest {

6 public static void main(String[] args) {

7 TreeSet ts = new TreeSet(new Teacher2.TeacherCompare());

8 ts.add(new Teacher2("zhangsan", 2));

9 ts.add(new Teacher2("lisi", 1));

10 ts.add(new Teacher2("wangmazi", 3));

11 ts.add(new Teacher2("mazi", 3));

12 Iterator it = ts.iterator();

13 while (it.hasNext()) {

14 System.out.println(it.next());

15 }

16 }

17 }

18

19 class Teacher2 {

20 int num;

21 String name;

22

23 Teacher2(String name, int num) {

24 this.num = num;

25 this.name = name;

26 }

27

28 public String toString() {

29 return "学号：" + num + " 姓名：" + name;

30 }

31

32 static class TeacherCompare implements Comparator {// 老师自带的一个比较器

33 //o1中存放的是目标节点

34 //o2中存放时的红黑二叉树中的节点，从根节点开始比较

35 public int compare(Object o1, Object o2) {

36 Teacher2 s1 = (Teacher2) o1;// 转型

37 Teacher2 s2 = (Teacher2) o2;// 转型

38 int result = s1.num > s2.num ? 1 : (s1.num == s2.num ? 0 : -1);

39 if (result == 0) {

40 result = s1.name.compareTo(s2.name);

41 }

42 return result;

43 }

44 }

45 }

打印输出:

学号：1 姓名：lisi

学号：2 姓名：zhangsan

学号：3 姓名：mazi

学号：3 姓名：wangmazi

//============================================================================

下面再讲一下Collections中的某些方法，Collections是集合的父类，里面有许多的静态方法，可以给他的子类对象提供许多功能

1.让LinkedList中的数值有序输出

示例代码:

1 import java.util.Collections;

2 import java.util.Comparator;

3 import java.util.LinkedList;

4

5 public class Test2 {

6 public static void main(String[] args) {

7 LinkedList list = new LinkedList();

8 list.add(new Integer(1));

9 list.add(new Integer(0));

10 list.add(new Integer(3));

11 list.add(new Integer(2));

12

13 //生成一个比较器

14 Comparator com = Collections.reverseOrder();//倒叙

15 Collections.sort(list,com);//list按照com的排列反方式排列.

16

17 //Collections.reverse(list);按照输入相反的顺序排列输出

18 //Collections.shuffle(list);乱序排列

19 //Collections.min(list);//集合中的最小值

20 //Collections.max(list);//集合中的最大值

21

22 }

23 }

2.Collections.shuffle()乱序排列。。。。

3.Collections.min();最小

4.Collections.max();最大