TreeSet的两种排序方式

最新推荐文章于 2024-08-14 22:53:03 发布
最新推荐文章于 2024-08-14 22:53:03 发布
阅读量214 收藏
点赞数
分类专栏： java基础 文章标签： set

转自：http://blog.csdn.net/xiaofei__/article/details/53138681
1.排序的引入
由于TreeSet可以实现对元素按照某种规则进行排序，例如下面的例子

public class TreeSetDemo {  
        public static void main(String[] args) {  
            // 创建集合对象  
            // 自然顺序进行排序  
            TreeSet<Integer> ts = new TreeSet<Integer>();  

            // 创建元素并添加  
            // 20,18,23,22,17,24,19,18,24  
            ts.add(20);  
            ts.add(18);  
            ts.add(23);  
            ts.add(22);  
            ts.add(17);  
            ts.add(24);  
            ts.add(19);  
            ts.add(18);  
            ts.add(24);  

            // 遍历  
            for (Integer i : ts) {  
                System.out.println(i);  
            }  
        }  
    }

运行结果为：

但是对自定义对象呢

 public class TreeSetDemo02 {  
        public static void main(String[] args) {  
            TreeSet<Student> ts=new TreeSet<Student>();       
            //创建元素对象  
            Student s1=new Student("zhangsan",20);  
            Student s2=new Student("lis",22);  
            Student s3=new Student("wangwu",24);  
            Student s4=new Student("chenliu",26);  
            Student s5=new Student("zhangsan",22);  
            Student s6=new Student("qianqi",24);  

            //将元素对象添加到集合对象中  
            ts.add(s1);  
            ts.add(s2);  
            ts.add(s3);  
            ts.add(s4);  
            ts.add(s5);  
            ts.add(s6);  

            //遍历  
            for(Student s:ts){  
                System.out.println(s.getName()+"-----------"+s.getAge());  
            }  
        }  
    }  

Student类：

    public class Student {  
        private String name;  
        private int age;  

        public Student() {  
            super();  
            // TODO Auto-generated constructor stub  
        }     

        public Student(String name, int age) {  
            super();  
            this.name = name;  
            this.age = age;  
        }  

        public String getName() {  
            return name;  
        }  

        public void setName(String name) {  
            this.name = name;  
        }  

        public int getAge() {  
            return age;  
        }  

        public void setAge(int age) {  
            this.age = age;  
        }  
    }

运行结果：

原因分析：
由于不知道该安照那一中排序方式排序，所以会报错。

解决方法：
1.自然排序
2.比较器排序

2.自然排序
自然排序要进行一下操作：

1.Student类中实现 Comparable接口
2.重写Comparable接口中的Compareto方法

int compareTo(T o)
比较此对象与指定对象的顺序。

故Student类为：特别注意在重写Compareto方法时，注意排序 


    package xfcy_04;  
    /** 
     * Student类 
     * @author 晓风残月 
     * 
     */  
    public class Student implements Comparable<Student> {  
        private String name;  
        private int age;  

        public Student() {  
            super();  
            // TODO Auto-generated constructor stub  
        }     

        public Student(String name, int age) {  
            super();  
            this.name = name;  
            this.age = age;  
        }  

        public String getName() {  
            return name;  
        }  

        public void setName(String name) {  
            this.name = name;  
        }  

        public int getAge() {  
            return age;  
        }  

        public void setAge(int age) {  
            this.age = age;  
        }  

        @Override  
        public int compareTo(Student s) {  
            //return -1; //-1表示放在红黑树的左边,即逆序输出  
            //return 1;  //1表示放在红黑树的右边，即顺序输出  
            //return o;  //表示元素相同，仅存放第一个元素  
            //主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树  
            int num=this.name.length()-s.name.length();    
            //姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。  
            //如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。  
            //如果这两个字符串相等，则结果为 0  
            int num1=num==0?this.name.compareTo(s.name):num;  
            //姓名的长度和内容相同，不代表年龄相同，所以还要判断年龄  
            int num2=num1==0?this.age-s.age:num1;  
            return num2;  
        }  

    }

而主类中为：

 package xfcy_04;  

    import java.util.TreeSet;  

    /* 
    * TreeSet存储自定义对象并保证排序和唯一。 
     *  
     * 需求：请按照姓名的长度排序 
     */  
    public class TreeSetDemo02 {  
        public static void main(String[] args) {  
            //创建集合对象          
            TreeSet<Student> ts=new TreeSet<Student>();  


            //创建元素对象  
            Student s1=new Student("zhangsan",20);  
            Student s2=new Student("lis",22);  
            Student s3=new Student("wangwu",24);  
            Student s4=new Student("chenliu",26);  
            Student s5=new Student("zhangsan",22);  
            Student s6=new Student("qianqi",24);  

            //将元素对象添加到集合对象中  
            ts.add(s1);  
            ts.add(s2);  
            ts.add(s3);  
            ts.add(s4);  
            ts.add(s5);  
            ts.add(s6);  

            //遍历  
            for(Student s:ts){  
                System.out.println(s.getName()+"-----------"+s.getAge());  
            }  
        }  
    }

运行结果：

3、比较器排序
比较器排序步骤：
1.单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口
2.重写Comparator接口中的Compare方法
int compare(T o1,T o2)
比较用来排序的两个参数。

3.在主类中使用下面的 构造方法

TreeSet(Comparator<? superE> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序。

主类：

  package xfcy_04;  

    import java.util.TreeSet;  

    /* 
    * TreeSet存储自定义对象并保证排序和唯一。 
     *  
     * 需求：请按照姓名的长度排序 
     */  
    public class TreeSetDemo02 {  
        public static void main(String[] args) {  
            //创建集合对象  
            //TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。  
            TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());  

            //创建元素对象  
            Student s1=new Student("zhangsan",20);  
            Student s2=new Student("lis",22);  
            Student s3=new Student("wangwu",24);  
            Student s4=new Student("chenliu",26);  
            Student s5=new Student("zhangsan",22);  
            Student s6=new Student("qianqi",24);  

            //将元素对象添加到集合对象中  
            ts.add(s1);  
            ts.add(s2);  
            ts.add(s3);  
            ts.add(s4);  
            ts.add(s5);  
            ts.add(s6);  

            //遍历  
            for(Student s:ts){  
                System.out.println(s.getName()+"-----------"+s.getAge());  
            }  
        }  
    }

MyComparator类：

  package xfcy_04;  

    import java.util.Comparator;  

    public class MyComparator implements Comparator<Student>{  

        @Override  
        public int compare(Student s1,Student s2) {  
            // 姓名长度  
            int num = s1.getName().length() - s2.getName().length();  
            // 姓名内容  
            int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;  
            // 年龄  
            int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;  
            return num3;  
        }  




    }

学生类（不需要继承Comparetable接口）

    package xfcy_04;  
    /** 
     * Student类 
     * @author 晓风残月 
     * 
     */  
    public class Student{  
        private String name;  
        private int age;  

        public Student() {  
            super();  
            // TODO Auto-generated constructor stub  
        }     

        public Student(String name, int age) {  
            super();  
            this.name = name;  
            this.age = age;  
        }  

        public String getName() {  
            return name;  
        }  

        public void setName(String name) {  
            this.name = name;  
        }  

        public int getAge() {  
            return age;  
        }  

        public void setAge(int age) {  
            this.age = age;  
        }  

    }

运行结果：

4.比较器修改

由于单独创建一个类不是特别好，因而可以将MyComparetor的内容直接写到主类中

public class TreeSetDemo {  
            public static void main(String[] args) {  
                    // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象  
            // 而匿名内部类就可以实现这个东西  
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {  
                @Override  
                public int compare(Student s1, Student s2) {  
                    // 姓名长度  
                    int num = s1.getName().length() - s2.getName().length();  
                    // 姓名内容  
                    int num2 = num == 0 ? s1.getName().compareTo(s2.getName())  
                            : num;  
                    // 年龄  
                    int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;  
                    return num3;  
                }  
            });  

            // 创建元素  
            Student s1 = new Student("linqingxia", 27);  
            Student s2 = new Student("zhangguorong", 29);  
            Student s3 = new Student("wanglihong", 23);  
            Student s4 = new Student("linqingxia", 27);  
            Student s5 = new Student("liushishi", 22);  
            Student s6 = new Student("wuqilong", 40);  
            Student s7 = new Student("fengqingy", 22);  
            Student s8 = new Student("linqingxia", 29);  

            // 添加元素  
            ts.add(s1);  
            ts.add(s2);  
            ts.add(s3);  
            ts.add(s4);  
            ts.add(s5);  
            ts.add(s6);  
            ts.add(s7);  
            ts.add(s8);  

            // 遍历  
            for (Student s : ts) {  
                System.out.println(s.getName() + "---" + s.getAge());  
            }  
        }  
    }

运行结果也如同上面一样

5.总结
A:自然排序：要在自定义类中实现Comparerable<T>接口 ，并且重写compareTo方法
B:比较器排序：在自定义类中实现Comparetor<t>接口，重写compare方法

cyywxy
关注
专栏目录
TreeSet的两种排序方式：自然排序和定制排序
tangwm的博客
09-20 5669
TreeSet的两种排序方式：自然排序和定制排序 TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。TreeSet有两种排序方法：自然排序和定制排序。默认采用自然排序。 1. 自然排序 要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法在此方法中，指明按照自定义类的哪个属性进行排序
重点描述TreeSet的两种排序方式
小树的博客
04-02 504
目录 1.背景介绍 2.TreeSet保证元素唯一和排序的原理 3.两种排序（自然排序，比较器排序） 4.自然排序的实现 4.1 Integer和String对象都可以进行默认的TreeSet排序 4.2对自定义对象进行 自然排序 5.比较器排序的实现 5.1 一般比较器写法 5.2常见比较器写法 1.背景介绍 TreeSet底层数据结构采用红黑树（平衡二叉树）来实现，元...
set集合实现排序
03-05
定义学生类，每个学生有3门课的成绩， 从键盘输入以上数据（包括姓名，三门课成绩）， 输入的格式：如：zhagnsan，30，40，60计算出总成绩， 并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。(如果总分相同，按照姓名排序)
TreeSet两种排序方式
wang_ouyangsima的博客
02-22 472
方法1；     public class Student {                 private int age;        private String name;                 public int getAge() {             return age;         }                  public void setAge...
TreeSet集合排序方式一：自然排序Comparable
weixin_30847939的博客
04-17 185
TreeSet集合默认会进行排序。因此必须有排序，如果没有就会报类型转换异常。 自然排序 Person class—>实现Comparable，实现compareTo（）方法 package Homework1and2; import java.text.CollationKey; import java.text.Collator; /** * Person...
浅谈TreeSet中的两种排序方式
08-30
Java 中 TreeSet 的两种排序方式 TreeSet 是 Java 中一种基于树形结构的 Set 实现，它具有自动排序的功能。在使用 TreeSet 时，我们可以通过实现 Comparable 接口或提供Comparator 对象来指定排序规则。下面，我们...
解决TreeSet类的排序问题
09-03
TreeSet提供两种排序方式：自然排序和定制排序。 1. 自然排序： 自然排序是TreeSet默认的排序方式。当向TreeSet中添加元素时，它会调用这些元素的`compareTo(Object obj)`方法进行比较。这个方法源自`Comparable`...
java中两种简单的排序方式：冒泡与TreeSet集合自动排序
zyshahaha的博客
09-01 532
先来讲最简单的冒泡排序： 一、冒泡排序算法的原理如下： 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在执行完一轮后，最后的元素应该会是最大的数。 3. 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 代码如下： for(int i =0 ; i<arr.length-1 ; i++) { for(int
TreeSet排序方法
qq_36558578的博客
01-14 1805
A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序 排序: a: 自然排序 b: 使用比较器排序 到底使用的是哪一种的排序取决于,构造方法. B:案例演示: TreeSet存储Integer类型的元素并遍历 存储下列元素: 20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24 注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要...
集合TreeSet（自然排序与定制排序）
liuchuangjin的博客
06-15 9264
一、TreeSet的自然排序： 步骤：让元素自身具备比较性， 实现Compareable接口，覆盖其CompareTo方法   class Student implements Comparable//第一：实现Compareable接口 {     private String name;     private int age;       Student(Strin
TreeSet的排序方式
最新发布
ADCvbV的博客
08-14 1037
例如字符串排序："aaa"，"aba"，"qwer"，"ab"，"cd"排序后为："aaa"，"ab"，"aba"，"cd"，"qwer"（默认是升序排序）从第一个开始比，只要发现大的就停止比较，对于"ab"和"aba"，"ab"前两个和"aba"一样，"ab"在第三个比"aba"少一个字母，默认比"aba"小。需求：创建TreeSet集合，并添加3个学生对象学生对象属性：姓名，年龄。要求按照学生的年龄进行排序同年龄按照姓名字母排列（暂不考虑中文）同姓名，同年龄认为是同一个人错解：​。
TreeSet进行排序的方法
weixin_44424630的博客
09-24 8292
TreeSet进行排序的方法的方法有两种，分别是 一种是类实现Comparable<>方法，重写compareTo(Object o)方法 public class Demo1 { public static void main(String[] args) { Student s1 = new Student("张三",25); Student s2 = new Student("李四",18); Student s3 = new
TreeSet排序
qq_50419321的博客
11-22 2948
TreeSet排序
TreeSet排序的两种方法
qq_41187393的博客
03-07 3137
TreeSet排序的两种方法 1.自然排序 ​ 实现Comparable接口,重写compareTo()方法 package com.qianfeng.kxf.day25.set.sort; import java.util.Set; import java.util.TreeSet; //TreeSet的自然排序 //1.实体类实现Comparable接口,重写compareTo()方法 ...
set中的排序
丰空岛主(Vega Prime,Android,LabWindows,ThreeJS,Python,OpenCV）
03-26 428
关于set，必须说明的是set是关联式容器。set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。C++ STL中标准关联容器set, multiset, map, multimap内部采用的就是一种非常高效的平衡检索二叉树：红黑树，也成为...
TreeSet排序（详细解析）
zmy766138的博客
12-22 6506
Java TreeSet排序（详细解析）
Treeset的两种排序方法
热门推荐
csf的专栏
07-15 1万+
转自：http://luochuang724.blog.163.com/blog/static/203606212201222821045518/Treeset 的自定义的两种排序方式 第一种：在元素中定义排序规则。元素自身具有比较性实现Comparable接口 覆盖compareTo方法 import java.util.Iterator; import java.util.TreeSet;
掌握TreeSet排序：自然排序与自定义比较详解
Java集合框架中的TreeSet类提供了两种排序机制，即自然排序和定制排序。默认情况下，TreeSet采用自然排序，它通过调用集合元素的`compareTo(Object obj)`方法来确定元素间的相对顺序。这个方法是Comparable接口的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值