精华内容
下载资源
问答
  • Java自学笔记:TreeSet自然排序
    2021-08-10 00:30:55
    public class trees {
        public static void main(String[] args) {
            //泛型是Integer
            Set<Integer> set = new TreeSet<Integer>();
            //TreeSet自然排序
            set.add(1);
            set.add(6);
            set.add(7);
            set.add(4);
            set.add(9);
            set.remove(6);
            System.out.println(set);
            System.out.println(set.contains(1));
    
            //用迭代器遍历集合
            Iterator<Integer> it1=set.iterator();
            
            while (it1.hasNext()){
                System.out.println(it1.next());
            }
            System.out.println("===================");
            for(Object obj:set){
                System.out.println(obj);
            }
        }
    }
    

    输出结果:

    [1, 4, 7, 9]
    true
    1
    4
    7
    9
    ===================
    1
    4
    7
    9

    当用类中的某个属性进行比较排序时,比如以人(类)的年龄大小来排序

    public class tree2 {
        public static void main(String[] args) {
    
            Person p1=new Person(12,"李华");
            Person p2=new Person(15,"李哈");
            Person p3=new Person(18,"李虎");
            Person p4=new Person(10,"李和");
            Set<Person> set=new TreeSet<Person>(new Person());
                set.add(p1);
                set.add(p2);
                set.add(p3);
                set.add(p4);
                for (Person b:set){
                    System.out.println(b.name+"   "+b.age);
                }
        }
    }
    //把Person对象存到TreeSet中并且按照年龄排序
     class Person implements Comparator<Person> {
        int age;
        String name;
    
        public  Person(){
    
        }
        public  Person(int age, String name){
            this.age=age;
            this.name=name;
        }
        //年龄正序排列
        @Override
        public int compare(Person o1, Person o2) {
    
            if (o1.age> o2.age){
                return  1;
    
            }else if (o1.age< o2.age){
                return -1;
            }else {
                return 0;
            }
        }
    }

    输出结果:

    李和   10
    李华   12
    李哈   15
    李虎   18

    更多相关内容
  • TreeSet中默认要求里面的元素进行自然排序,强制要求里面的所有元素必须按照Comparable中的compareTo方法进行比较。 类需实现Comparable接口,并重写方法compareTo(Object obj) 方法。 两个对象即通过 ...

    1.自然排序

    • 在TreeSet中默认要求里面的元素进行自然排序,强制要求里面的所有元素必须按照Comparable中的compareTo方法进行比较。

    • 类需实现Comparable接口,并重写方法compareTo(Object obj) 方法。

    • 两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj,则返回正整数,如果当前对象this小于形参对象obj,则返回负整数,如果当前对象this等于形参对象obj,则返回零。

    • TreeSet实例在调用add方法时会调用容器对象的compareTo方法对元素进行比较

    • TreeSet实例中对象必须是实现了Comparable接口

    示例:按照年龄比较;当年龄相等返回0,大于返回1,小于返回-1
    User类:

    public class User implements Comparable{
    
        private String name;
        private int age;
    
        public User() {
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public int compareTo(Object o) {
            //比如按照年龄比较;当年龄相等返回0,大于返回1,小于返回-1
            User user = (User)o;
            if(this.age > user.age){
                return 1;
            }else if(this.age<user.age){
                return -1;
            }else{
                return this.name.compareTo(user.name);
            }
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    测试类:

    @Test
        public void test01(){
            TreeSet set = new TreeSet();
            set.add(new User("xx",18));
            set.add(new User("yy",16));
            set.add(new User("zz",12));
    
            Iterator iterator = set.iterator();
    
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    

    实验结果:
    在这里插入图片描述

    2.定制排序

    • 重写compare(Object o1,Object o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示 o1小于o2

    User类:

    public class User{
    
        private String name;
        private int age;
    
        public User() {
        }
    
        public User(String name, int age) {
            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 String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    测试类:

     @Test
        public void test01(){
            
            Comparator com = new Comparator() {
               //按照年龄从小到大排列
                @Override
                public int compare(Object o1, Object o2) {
                    if(o1 instanceof User && o2 instanceof User){
                        User u1 = (User)o1;
                        User u2 = (User)o2;
                        return Integer.compare(u1.getAge(),u2.getAge());
                    }else{
                        throw new RuntimeException("输入的数据类型不匹配");
                    }
                }
            };
    
    
            TreeSet set = new TreeSet(com);
            set.add(new User("xx",18));
            set.add(new User("yy",16));
            set.add(new User("zz",12));
    
            Iterator iterator = set.iterator();
    
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    

    实验结果:
    在这里插入图片描述

    展开全文
  • public int compare(String o1,String o2) { return o1.length()-o2.length();... TreeSet ts = new TreeSet(com); ts.add("string"); ts.add("char"); ts.add("nothing�"); System.out.println(ts);
  • import java.util.Iterator; import java.util.TreeSet; ... //自然排序 natrueSort(); //指定排序 fingerMustSort(); } private static void fingerMustSort() { TreeSe..
    
    
    package com.boyong;
    
    import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Set {
    
    	public static void main(String[] args) {
    		
    		//自然排序
    		natrueSort();
    		
    		//指定排序
    		fingerMustSort();
    		
    	}
    	
    	private static void fingerMustSort() {
    
    		TreeSet<ProfitAddLoss> set = new TreeSet<>();
    		//(收入,成本,利润): 指定利润升序排列
    		set.add(new ProfitAddLoss(100, 50, 50));
    		set.add(new ProfitAddLoss(100, 80, 20));
    		set.add(new ProfitAddLoss(100, 60, 40));
    		set.add(new ProfitAddLoss(100, 30, 70));
    		
    		Iterator<ProfitAddLoss> iterator = set.iterator();
    		while(iterator.hasNext()) {
    			ProfitAddLoss obj = iterator.next();
    			System.out.println(obj.liRun);
    		}
    		
    	}
    
    	private static void natrueSort() {
    
    		TreeSet<Object> set = new TreeSet<>();
    		boolean add = set.add(1);
    		boolean add2 = set.add(1);
    		boolean add3 = set.add(2);
    		boolean add4 = set.add(3);
    		
    		System.out.println(add);
    		System.out.println(add2);//插入失败
    		System.out.println(add3);
    		System.out.println(add4);
    		
    		Iterator<Object> iterator = set.iterator();
    		while(iterator.hasNext()) {
    			Object obj = iterator.next();
    			System.out.println(obj);
    		}
    		
    	}
    
    	@SuppressWarnings("all")
    	private static class ProfitAddLoss implements Comparable<ProfitAddLoss>{//损益
    		
    		private double shouRu;//收入
    		private double chengBen;//成本
    		private double liRun;//利润
    		
    		@Override
    		public int compareTo(ProfitAddLoss o) {
    			if (this.liRun <= o.liRun) {//利润多的靠前
    				return 1;
    			}
    			return -1;
    		}
    		
    		public ProfitAddLoss(double shouRu, double chengBen, double liRun) {
    			super();
    			this.shouRu = shouRu;
    			this.chengBen = chengBen;
    			this.liRun = liRun;
    		}
    		public double getShouRu() {
    			return shouRu;
    		}
    		public void setShouRu(double shouRu) {
    			this.shouRu = shouRu;
    		}
    		public double getChengBen() {
    			return chengBen;
    		}
    		public void setChengBen(double chengBen) {
    			this.chengBen = chengBen;
    		}
    		public double getLiRun() {
    			return liRun;
    		}
    		public void setLiRun(double liRun) {
    			this.liRun = liRun;
    		}
    		
    	}
    	
    }
    
    
    
    
    展开全文
  • TreeSet自然排序

    2018-03-11 20:49:20
    * 只有实现了该方法,才能让Student的所有对象,具有自然排序的属性。 *  *  */ @Override public int compareTo(Student o) { /** * 两个对象,谁大,谁小,自己定 *  * 例如:...
    package com.newedu.jb.day18.set;


    public class Student implements Comparable<Student>{

    private String name;
    private int age;
    public Student(String name, int age) {
    super();
    this.name = name;
    this.age = age;
    }
    public Student() {
    super();
    }
    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 String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
    }
    @Override
    public boolean equals(Object obj) {
    if (this == obj)
    return true;
    if (obj == null)
    return false;
    if (getClass() != obj.getClass())
    return false;
    Student other = (Student) obj;
    if (age != other.age)
    return false;
    if (name == null) {
    if (other.name != null)
    return false;
    } else if (!name.equals(other.name))
    return false;
    return true;
    }

    /**
    * 只有实现了该方法,才能让Student的所有对象,具有自然排序的属性。


    */
    @Override
    public int compareTo(Student o) {
    /**
    * 两个对象,谁大,谁小,自己定

    * 例如:下面是一种方案:
    *  只比较学生类的对象的年龄;
    *  对象的年龄大了,我们就认为该对象。
    *  
    *  
    *  另外一种方案:
    *  如果比较两个对象的大小,常见的方案,逐个比较成员变量;
    *  如果常用变量相等了,才需要进一步比较第二个成员变量。
    */
    //从小到大
    // return this.age<o.age? -1 :(this.age==o.age?0:1);

    //从大到小
    // return this.age<o.age? 1 :(this.age==o.age?0:-1);

    // "aa","b"
    int num = this.name.compareTo(o.name);

    //如果名字已经比较出来了大小,就不再需要进一步的比较年龄了。
    //否则 名字 相等的情况下,才需要进一步比较年龄
    // 从大到小
    return num != 0?num:(this.age<o.age? 1 :(this.age==o.age?0:-1));
    }



    }

    package com.newedu.jb.day18.set;


    import java.util.TreeSet;


    /**
     * TreeSet的特点:
     * 是Set接口的实现类
     * 
     * 1:内部依赖 红黑树(自平衡二叉树) 默认对元素进行自然排序
     * 2:元素不允许重复
     * 3:不允许null值的出现。
     * 4:存取有序吗? 存取无效
     * 5:线程不安全,效率高
     * 
     * 举例说明:
     * 
     * 存取Integer类型,并且遍历
     * 
     * 
     * 什么叫自然排序?
     * 
     * Comparable接口,此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
     * 
     *    只有一个方法 int compareTo(T t)
     *     该方法的返回值,有三种可能:
     *     负整数:小于指定对象
     *        零:等于指定对象
     *     正整数:大于指定对象
     *     
     *     
     *  再举一个自定义类型的存储(Student),并且遍历
     *  
     *  
     *  构造方法:
     *  TreeSet() 
              构造一个新的空 set,该 set 根据其元素的自然顺序进行排序
              
        TreeSet(Comparator<? super E> comparator) 
              构造一个新的空 TreeSet,它根据指定比较器进行排序。 自定义排序
     */
    public class TreeSetDemo1 {


    public static void main(String[] args) {


    //第一步:创建集合对象
    TreeSet<Integer> tset = new TreeSet<Integer>();


    //第二步:创建集合元素

    Integer i1 = 3;
    Integer i2 = 2;
    Integer i3 = 7;
    Integer i4 = 5;
    Integer i5 = 9;
    Integer i6 = 4;
    Integer i7 = 5;//重复值
    Integer i8 = null;

    //第三步:向集合中添加元素

    tset.add(i1);
    tset.add(i2);
    tset.add(i3);
    tset.add(i4);
    tset.add(i5);
    tset.add(i6);
    tset.add(i7);
    // tset.add(i8);//null值不允许
    // return (x < y) ? -1 : ((x == y) ? 0 : 1);

    //第四步:遍历集合
    for(Integer item :tset){
    System.out.print(item);
    System.out.print(",");
    }

    System.out.println("=========自定义类型Student===============");

    /**
    * Exception in thread "main" java.lang.ClassCastException: com.newedu.jb.day18.set.Student cannot be cast to java.lang.Comparable
    at java.util.TreeMap.compare(TreeMap.java:1294)
    at java.util.TreeMap.put(TreeMap.java:538)
    at java.util.TreeSet.add(TreeSet.java:255)
    at com.newedu.jb.day18.set.TreeSetDemo1.main(TreeSetDemo1.java:80)


    */
    TreeSet<Student> tset1 = new TreeSet<Student>();

    Student stu1 = new Student("jerry",20);

    Student stu2 = new Student("susan",19);

    Student stu3 = new Student("peter",18);
    Student stu4 = new Student("jerry",18);

    tset1.add(stu1);
    tset1.add(stu2);
    tset1.add(stu3);
    tset1.add(stu4);

    for(Student stu : tset1){
    System.out.println("集合元素:"+stu);
    }

    }


    }

    展开全文
  • 解决方案,Java提高了两种TreeSet的排序规则**,自然排序**(默认情况下,TreeSet集合采用自然排序)和定制排序 自然排序 自然排序要求TreeSet集合中存储的元素所在的类必须实现Comparable接口,并重写comoareTo()...
  • //TreeSet自然排序与定制排序,//1. 自然排序需要类实现Comparable接口,重写compareTo(),由于Set的不可重复性,要保证具有相同属性的元素不被重复添加,就需 要重写添加进Set的元素类的equals()和ha...
  • TreeSet自然排序(Comparable) 重点知识: TreeSet中的加入的元素会自动进行排序 TreeSet中只能加入同一个类类型创建出来的对象 因为我们的TreeSet中加入的元素会自动将进行排序,那么到底是如何进行排序的? 我们...
  • TreeSet自然排序 @Test public void test1(){ TreeSet set = new TreeSet(); //失败:不能添加不同类的对象 // set.add(123); // set.add(456); // set.add("AA"); // set.add(new User("Tom",12)); //举例...
  • 这里主要讲解的是对象排序(按某个属性或某种规则) 首先要明白,TreeSet为...TreeSet 要实现自然排序,或者说它是怎么实现自然排序的,主要还是因为,TreeSet 排序引用类型时时通过compareTo方法的返回值来判断顺...
  • java Set接口的实现类TreeSet 自然排序 定制排序1.TreeSet 自然排序2.TreeSet 定制排序 1.TreeSet 自然排序 TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按...
  • TreeSet自然排序

    2019-09-24 16:56:38
    /*TreeSet: * 1.向 TreeSet中添加的元素...当向TreeSet中添加自定义类的对象时,有两种排序方法:①自然排序②定制排序 * 4.自然排序:要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object o)抽象方...
  • TreeSet集合中添加类对象时,类对象的类必须实现Comparable接口,重写compareTo()方法。 两个测试实体类 /** * 生日实体类 */ public class MyDate { private int year; private int month; private int ...
  • //这个学生类中,如果要进行自然排序(测试类中:通过TreeSet()创建对象),这个类必须实现接口:Comparable public class Student implements Comparable<Student>{ //提供两个属性 private Stri
  • TreeSet集合,自然排序
  • TreeSet自然排序和定制排序

    千次阅读 2017-07-31 07:15:49
    (该方法不能自动生成)自然排序(Comparable) TreeSet拥有的集合元素的compareTo()方法来比较元素的大小关系,然后将集合元素按照升序排列。 int compareTo(T o) 将此对象与指定的对象进行比较,以返
  • treeset集合,自然排序

    2019-09-24 19:12:15
    2.4.2.TreeSet 案例:使用TreeSet集合存储字符串元素,并遍历 import java.util.TreeSet; public class Demo5 { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(“ccc”); ts.add(...
  • 本教程特点: 1.更适合零基础学员: ·自Java语言起源始,循序渐进,知识点剖析细致且每章配备大量随堂练习,让你步步为营,学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学,宋老师语言生动幽默,举例形象生动深入浅...
  • 1.自然排序 对象类: public class Examinee implements Comparable{//实现接口 private int scorce; //构造方法与get、set方法略 @Override public String toString() { return this.getScorce(...
  • TreeSet的两种排序方式:自然排序和定制排序 TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态。TreeSet有两种排序方法:自然排序和定制排序。默认采用自然排序。 1. 自然排序 要求自定义类...
  • Java集合--TreeSet排序

    2021-11-16 20:49:21
    TreeSet自然排序,比较器排序
  • 自然排序和比较器排序 ​ 当指执行插入排序、希尔排序、归并排序等算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行排序时,如何比较两个对象的“大小...
  • TreeSet的几大特点: 1、TreeSet中存储的类型必须是一致的,不能一下存int,一下又存string 2、TreeSet在...有2种排序方法,1:自然排序 2、定制排序 自然排序:要求自定义类实现java.lang.Comparable接口并重写co...
  • TreeSet集合及构造器排序和自然排序详解和特点 1.TreeSet集合特点 元素有序,这里的顺序不是指存储和取出的顺序,而是按照一定的规则进行排序,具体排序方式取决于构造方法 TreeSet():根据其元素的自然排序进行...
  • TreeSet: public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, SerializableA...元素有序,这里的顺序不是指存储和取出的顺序,而是按照一定的顺序进行排序,具体排序方式取决于构造方法 Tr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,144
精华内容 10,857
关键字:

treeset自然排序