• 关于TreeSet倒序排列和自定义排列


    本文部分转自:http://blog.csdn.net/kaituozhe345/article/details/6842945

    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<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.println(iteratorStr.next() + " ");
    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.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<Person> tree= new TreeSet<Person>();
     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<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.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 + "		姓名:" + 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<E,Object>(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<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.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<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 = 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();最大

  • 相关阅读:
    设计模式《JAVA与模式》之解释器模式
    设计模式《JAVA与模式》之状态模式
    设计模式《JAVA与模式》之备忘录模式
    设计模式《JAVA与模式》之责任链模式
    设计模式《JAVA与模式》之命令模式
    设计模式《JAVA与模式》之迭代子模式
    iOS-联系人应用(一)
    简易 HTTP Server 实现(JAVA)
    IBM Websphere 集群会话共享问题解决办法
    集群会话共享问题的几种处理方式
  • 原文地址:https://www.cnblogs.com/DreamDrive/p/5487087.html
Copyright © 2020-2023  润新知