精华内容
下载资源
问答
  • TreeSet 两种排序方法

    千次阅读 2018-05-20 20:48:56
    TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序。自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序排列。如果试图把...

    TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序。

    自然排序:

    TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序排列。

    如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable 接口。

    实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。

    Comparable 的典型实现:
    BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
    Character:按字符的 unicode值来进行比较
    Boolean:true 对应的包装类实例大于 false 对应的包装类实例
    String:按字符串中字符的 unicode 值进行比较

    Date、Time:后边的时间、日期比前面的时间、日期大

    向 TreeSet 中添加元素时,只有第一个元素无须实现 Comparable 接口,后面添加的所有元素都必须实现 Comparable 接口
    因为只有相同类的两个实例才会比较大小,所以向 TreeSet 中添加的应该是同一个类的对象。
    对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值。

    当需要把一个对象放入 TreeSet 中,重写该对象对应的 equals() 方法时,应保证该方法与 compareTo(Object obj) 方法有一致的结果:如果两个对象通过 equals() 方法比较返回 true,则通过 compareTo(Object obj) 方法比较应返回 0。

    定制排序:

    TreeSet的自然排序是根据集合元素的大小,进行元素升序排列。如果需要定制排序,比如降序排列,可通过Comparator接口的帮助。需要重写compare(T o1,T o2)方法。
    利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
    要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
    此时,仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
    使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0。


    展开全文
  • 使用TreeSet实现定制排序 我们知道: 一、TreeSet类不但实现了Set的接口,而且还实现了所谓的的java.util.SortedSet接口,所以呢在遍历集合时会进行默认的排序,即升序排列。 eg1(Integer): package Set类; ...

    使用TreeSet实现定制排序

    我们知道:
    一、TreeSet类不但实现了Set的接口,而且还实现了所谓的的java.util.SortedSet接口,所以呢在遍历集合时会进行默认的排序,即升序排列。
    eg1(Integer):

    package Set类;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    //创建一个(默认的升序)UnTreeSetTest类...
    public class UnTreeSetTest {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		TreeSet<Integer> achievements =new TreeSet<Integer>();
    		//向该集合中添加元素...啦啦啦
    		achievements.add(-8);
    		achievements.add(5);
    		achievements.add(0);
    		achievements.add(-3);
    		achievements.add(6);
    		//创建Iterator迭代器...啦啦啦
    		Iterator<Integer> superiter = achievements.iterator();
    		//遍历得到集合元素》...嘻嘻嘻
    		while(superiter.hasNext()) {//这个应该都知道吧...哈哈哈
    			System.out.println(superiter.next());
    		}
    		
    		
    	}
    
    }
    
    

    运行结果:在这里插入图片描述

    package Set类;
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    //创建一个(默认的升序)UnTreeSetTest类...
    public class UnTreeSetTest {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		TreeSet<Character> achievements =new TreeSet<Character>();
    		//向该集合中添加元素...啦啦啦
    		achievements.add('h');
    		achievements.add('d');
    		achievements.add('r');
    		achievements.add('k');
    		achievements.add('t');
    		//创建Iterator迭代器...啦啦啦
    		Iterator<Character> superiter = achievements.iterator();
    		//遍历得到集合元素》...嘻嘻嘻
    		while(superiter.hasNext()) {//这个应该都知道吧...哈哈哈
    			System.out.println(superiter.next());
    		}
    		
    		
    	}
    
    }
    
    

    运行结果:运行结果:
    以上就是默认升序;
    二、那如何使用使用TreeSet实现降序排序呢?我们需要使用Comparator接口
    eg3(Integer):

    package Set类;
    import java.util.TreeSet;
    import java.util.Comparator;
    public class OrderTreeSet {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Integer sequence1 = new Integer(9);
    		Integer sequence2 = new Integer(-3);
    		Integer sequence3 = new Integer(0);
    		Integer sequence4 = new Integer(3);
    		Integer sequence5 = new Integer(-2);
    		TreeSet<Integer>treeSet = new TreeSet<Integer>(new Comparator<Integer>() {
    			public int compare(Integer o1, Integer o2) {
    				return -(o1-o2);
    			}
    	});
    		treeSet.add(sequence1);
    		treeSet.add(sequence2);
    		treeSet.add(sequence3);
    		treeSet.add(sequence4);
    		treeSet.add(sequence5);
    		System.out.println(treeSet);
    }
    }
    

    运行结果:运行结果:
    eg4(Character):

    package Set类;
    import java.util.TreeSet;
    import java.util.Comparator;
    public class OrderTreeSet {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Character sequence1 = new Character('h');
    		Character sequence2 = new Character('o');
    		Character sequence3 = new Character('g');
    		Character sequence4 = new Character('v');
    		Character sequence5 = new Character('a');
    		TreeSet<Character>treeSet = new TreeSet<Character>(new Comparator<Character>() {
    			public int compare(Character o1, Character o2) {
    				return -(o1-o2);
    			}
    	});
    		treeSet.add(sequence1);
    		treeSet.add(sequence2);
    		treeSet.add(sequence3);
    		treeSet.add(sequence4);
    		treeSet.add(sequence5);
    		System.out.println(treeSet);
    }
    }
    

    运行结果:
    运行结果:
    以上就是关于TreeSet定制排序(降序)的相关问题了,希望对大家有帮助。

    展开全文
  • TreeSet进行排序方法

    2021-09-24 10:04:41
    TreeSet进行排序方法方法有两种,分别是 一种是类实现Comparable<>方法,重写compareTo(Object o)方法 public class Demo1 { public static void main(String[] args) { Student s1 = new Student(...

    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 Student("王五",20);
    
            //Student类实现Comparable接口,TreeSet就可以对学生进行自然排序
            TreeSet<Student> ts = new TreeSet<>();
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
    
            for(Student s : ts){
                System.out.println(s);
            }
    
        }
    }
    //学生类实现Comparable接口,TreeSet就可以对学生进行自然排序
    public class Student implements Comparable<Student>{
    
        private String name;
        private  int age;
    
        //实现元素排序的规则
        /*
            根据返回值排序
                返回的负数,认为当前要存入的元素比较小,存左边
                返回的正数,认为当前要存入的元素比较大,存右边
                返回的0,认为当前要存入的元素已经存在,不存入
         */
        @Override
        public int compareTo(Student o) {
            //按照年龄升序排序 (从小到大)
            return this.age - o.age;
    
            //按照年龄降序排序(从大到小)
            //return o.age - this.age;
        }

    底层原理是:

    CompareTo(Student o){      return  =this.age-o.age      }:根据类型进行比较
    例如三个学生对象,第一个存进去,第二个跟第一个比较,如果比较后为负数,则在左边存储,第三个先跟第一个比较,如果为负数则存进左边,如果为正数,然后就跟第二个对象比较,也是负数存左边,正数存右边
    返回的是负数:认为当前要存入的元素比较小,存黑红树左边
    返回的是正数:认为当前要存入的元素比较大,存黑红树右边
    返回的是0:认为当前要存入的元素已经存在,不存入

    另一种为:Comparetor比较器

    方式:TreeSet<Student> a = new TreeSet<>(new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    return o2.getAge()-o1.getAge();
                }

            });
        当属性不是int,而是double时,不能强制,因为会有精度问题,应该用if条件判断这个数到底是正数负数还是0
    原理跟CompareTo方法是一样的,都是根据返回值来计算

    展开全文
  • TreeSet<Employee> treeSet = new TreeSet(); Employee employee = new Employee("小明", 20, 2000); Employee employee1 = new Employee("小张", 27, 2000); Employee employee2 = new Employee("小红", 30...

    建一个员工类 继承Comparaple 

    
    public class Employee implements Comparable<Employee> {
    
    	private String name;
    	private int age;
    	private double salary;
    
    	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;
    	}
    
    	public double getSalary() {
    		return salary;
    	}
    
    	public void setSalary(double salary) {
    		this.salary = salary;
    	}
    
    	public Employee(String name, int age, double salary) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.salary = salary;
    	}
    
    	public Employee() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	@Override
    	public int compareTo(Employee o) {// 那当前 员工对象和外来员工对象进行比较 (自然顺序比较是小的在前大的在后)
    		if (this.getAge() > o.getAge()) {
    			return -1;// this-o小于0,表示this在前 o在后
    		} else if (this.getAge() == o.getAge()) {
    
    			if (this.getSalary() > o.getSalary()) {
    				return -1;
    			} else if (this.getSalary() == o.getSalary()) {
    				if (this.getName().hashCode() > o.getName().hashCode()) {
    					return -1;// 返回小于0的值,当前对象在前,外来对象在后
    				} else if (this.getName().hashCode() == o.getName().hashCode()) {
    					return 0;// 同一个对象
    				} else {
    					return 1;
    				}
    			} else {
    				return 1;// 返回大于0的值,当前对象在后,外来对象在前
    			}
    		} else {
    			return 1;// this-o大于0,表示this在后 o在前
    		}
    
    	}
    
    }

    测试类Demo

    package com.zhiyou.wch3;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.TreeSet;
    
    public class Demo {
    	public static void main(String[] args) {
    
    		TreeSet<Employee> treeSet = new TreeSet<>();
    		Employee employee = new Employee("小明", 20, 2000);
    		Employee employee1 = new Employee("小张", 27, 2000);
    		Employee employee2 = new Employee("小红", 30, 2000);
    		Employee employee3 = new Employee("小李", 20, 2000);
    		Employee employee4 = new Employee("小明", 20, 2000);
    		Employee employee5 = new Employee("小明", 25, 2000);
    		Employee employee6 = new Employee("小明", 20, 4000);
    		treeSet.add(employee6);
    		treeSet.add(employee5);
    		treeSet.add(employee4);
    		treeSet.add(employee3);
    		treeSet.add(employee2);
    		treeSet.add(employee1);
    		treeSet.add(employee);
    		Iterator<Employee> iterator = treeSet.iterator();
    		while (iterator.hasNext()) {
    			Employee emp = iterator.next();
    			System.out.println(emp.getAge() + "\t" + emp.getSalary() + "\t" + emp.getName().hashCode());
    		}
    
    	}
    
    }
    

     

    展开全文
  • 首先,我们要了解TreeSet 点击 TreeSet 的源码我们可以看到 TreeSet 的底层是 TreeMap 而 TreeMap 的底层是基于红黑树实现的,那么什么是红黑树呢? 那我们就不得不提到二叉树,因为红黑树是二叉树的升级版 二叉树 ...
  • java Set接口的实现类TreeSet 自然排序 定制排序1.TreeSet 自然排序2.TreeSet 定制排序 1.TreeSet 自然排序 TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按...
  • 降序 package Set类; import java.util.TreeSet; import java.util.Comparator; public class OrderTreeSet { public static void main(String[] args) { // TODO Auto-generated method stub Integer sequence...
  • 一、对int、String类型进行降序输出 1、存储int类型时 public static void main(String[] args) { TreeSet<Integer> intSet = new TreeSet<>(); intSet.add(23); intSet.add(68); intSet.add(33)...
  • 下面介绍java中对对List、Set、Map的升序、降序排序的常用写法 1、List排序: 2、Set排序: 3、Map排序:
  • import java.util.ArrayList; import java.util.Scanner; import java.util.TreeSet;... * 队伍比赛安排 涉及自定义对象的排序TreeSet特性与应用 * eg:10001:50+10002:45+10003:50+10004:43 * @author
  • 前言:TreeSet和HashSet的区别在于, HashSet不可以进行排序TreeSet可以进行排序, 默认使用字典顺序排序, 也可以进行自定义排序。 1,但实际使用HashSet时会发现,HashSet好像会自动进行了排序,为什么呢? 原因...
  • TreeSet对String的排序

    2020-10-06 20:44:49
    TreeSet集合中的元素:无序不可重复,但是可以按照元素大小顺序自动排序 TreeSet集合放进去无序,拿出来有序 package collection; import java.util.TreeSet; public class TreeSetTest02 { public static void ...
  • 【JAVA】用Comparable接口学生的成绩做降序排序!请正确指定泛型;用Comparator实现按照姓名排序,请正确指定泛型! 创建四个学生信息,分别包含姓名(String) , 年龄(int) ,分数(double) (1)用Comparable...
  • Set集合之TreeSet排序详解

    千次阅读 2019-05-09 10:45:23
    这时,我们可能会有很多解决办法,比如说:for循环,把每一个数字都与当前数字进行比较,根据需要看是升序还是降序排列,再交换两个数字的位置,这种方法叫选择排序. 其实在Set中有一个它的子类:TreeSet,它可以实现集合的...
  • 关于TreeSet排序问题

    2017-01-04 12:10:43
    TreeSet支持两种排序方法:自然排序和定制排序。TreeSet默认采用自然排序。   1、自然排序 TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系,然后将集合元素按升序排列,这种方式就是...
  • TreeSet的两种排序方式

    万次阅读 2018-08-21 23:53:40
    TreeSet 实现SortedSet接口,此接口用于排序操作,因此该接口的实现类具有排序能力,下面主要通过小工具进行说明。 一.首先看一下对基本类型的排序 输出结果: 1 10 13 28 110 结论:默认进行正序排...
  • Java—TreeSet TreeSet是一个有序的集合,它的作用是提供有序的Set集合,在java中使用。 下面我们来进行一个实例来操作一下,...1.定义学生类student和集合TreeSet集合对象,然后使用Comparator比较排序器来排序。 2.
  • java中的各种集合排序之set中TreeSet集合排序

    千次阅读 多人点赞 2019-05-03 15:06:01
    1.软件开发过程中集合排序是比较强大的功能,会使用集合Map、Set、List实现排序功能,知道匿名内部类Comparator很关键,搞清楚集合排序的性能开销,排序遇到的坑以及解决的方法,注意下面的例子都是JDK1.8的用法。...
  • TreeSet集合,自然排序
  • Treeset的两种排序方法

    万次阅读 2013-07-15 17:58:22
    转自:http://luochuang724.blog.163.com/blog/static/203606212201222821045518/Treeset 的自定义的两种排序方式 第一种:在元素中定义排序规则。元素自身具有比较性实现Comparable接口 覆盖compareTo方法 import ...
  • monthset =new TreeSet&lt;String&gt;(new Comparator&lt;String&gt;(){ public int compare(String s1, String s2) { SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM"); ...
  • 排序方法 @Override public int compareTo(NewMonthPerEntity o) { double a1 = this .whichProperty.equals("leadTotal5") ? this .leadTotal5 : ( this .whichProperty.equals("leadTotal4") ? this...
  • 超级简单的Lambda实现TreeSet排序

    千次阅读 2020-04-05 00:14:41
    TreeSet对实体对象进行排序的时候,因为TreeSet...那么对TreeSet中支持的两种排序:自然排序和自定义比较器排序,我在之前的一篇文章中有做了代码解释TreeSet排序的两种方法 虽然这两种方法可以实现TreeSet排序,...
  • 自定义 TreeSet排序规则(按电话号码降序),整理给定的电话簿。 编程要求 接收给定的一行字符串(该字符串属于电话簿,包含多个电话号码,如:13545453432,13678909808); 自定义 TreeSet排序规则(按...
  • 如果你想降序或者按照对象来排序,可以借助于比较器的方式来实现。 下面是一段简单的TreeSet集合排序测试代码: public static void main(String[] args) { SortedSet ages = new TreeSet(); ages.add(69); ...
  • 使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的Comparator进行排序,具体取决于使用的构造方法。 存储特点: 无序存储,排重,通过红黑树实现的集合,可以给元素进行重新排序 我们知道Set...
  • 演示TreeSet对String是可排序的 1.TreeMap集合底层实际上是一个TreeMap 2.TreeMap集合底层是一个二叉树 3.放到TreeSet集合中的元素,等同于放到TreeMap集合key部分了 4.TreeSet集合中的元素,无序不可重复,但是可以...
  • http://www.toutiao.com/a6347848405252309249/?tt_from=mobile_qq&utm_campaign=client_share&app=explore_article&utm_source=mobile_qq&iid=5840657922&utm_medium=toutiao_ios
  • 键盘录入学生信息(姓名,语文/数学/英语成绩),按照总分降序排序后,写入文件中 1.定义学生类 2.创建集合,通过比较器进行排序 3.键盘录入学生数据 4.创建学生对象,将录入的数据赋值给对应的学生属性 5.把学生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,820
精华内容 1,928
关键字:

treeset降序排序方法