关于TreeSet倒序排列和⾃定义排列
本⽂部分转⾃:
1.TreeSet的⾃然排序.
TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
Integer能排序(有默认顺序), String能排序(有默认顺序), ⾃定义的类存储的时候出现异常(没有顺序).
TreeSet中的元素将按照升序排列，缺省是按照⾃然排序进⾏排列，意味着TreeSet中的元素要实现Comparable接⼝。如果要想使集合中的顺序按照降序排列的话需要⽤到TreeSet的descendingSet()⽅法.
1 package st;
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<String> treeStr = new TreeSet<String>();
11        TreeSet<String> treeReverseStr= new TreeSet<String>();
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.() + " ");
26        }
27
28
29        //Integer类型降序
30        TreeSet<Integer> tree = new TreeSet<Integer>();
31        TreeSet<Integer> treeReverse = new TreeSet<Integer>();
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.() + " ");
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<Person> tree= new TreeSet<Person>();
java集合排序怎么实现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: st.Person cannot be cast to java.lang.Comparable
at java.util.TreeMappare(Unknown Source)
at java.util.TreeMap.put(Unknown Source)
at java.util.TreeSet.add(Unknown Source)
at st.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<Teacher> ts = new TreeSet<Teacher>();
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<Teacher> it = ts.iterator();
14            while (it.hasNext()) {
15                System.out.());
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 = namepareTo(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<E,Object>(comparator));
3    }
通过查看它的构造⽅法就知道可以传⼊⼀个⽐较器。
构造⼀个新的空TreeSet，它根据指定⽐较器进⾏排序。插⼊到该 set 的所有元素都必须能够由指定⽐较器进⾏相互⽐较：对于 set 中的任意两个元素 e1 和e2，执⾏ comparatorpare(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<Teacher2> ts = new TreeSet<Teacher2>(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<Teacher2> it = ts.iterator();
13        while (it.hasNext()) {
14            System.out.());
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.namepareTo(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<Integer> list = new LinkedList<Integer>();
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 = verseOrder();//倒叙
15        Collections.sort(list,com);//list按照com的排列反⽅式排列.
16
17        //verse(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()；最⼤

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。