精华内容
下载资源
问答
  • 2021-08-14 00:07:18

    自定义类型存储,如Student和Teacher类型数据等,由于这些自定义的类型的数据没有实现Comparable接口,因此无法直接在TreeSet集合中进行排序操作

    解决方案,Java提高了两种TreeSet的排序规则**,自然排序**(默认情况下,TreeSet集合采用自然排序)和定制排序

    • 自然排序

      自然排序要求TreeSet集合中存储的元素所在的类必须实现Comparable接口,并重写comoareTo()方法,然后TreeSet集合就会对该类型使用compareTo()方法进行比较,并默认进行升序排序

    package com.sgl;
    
    import java.util.TreeSet;
    
    //定义Teacher类实现Comparable接口
    class Teacher implements Comparable {
        String name;
        int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return name + ":" + age;
        }
    
        @Override
        public int compareTo(Object obj) {
            Teacher s = (Teacher) obj;
            //定义比较方式,先比较年龄age,在比较名称name
            if (this.age - s.age > 0) {
                return 1;
            }
            if (this.age - s.age == 0) {
                return this.name.compareTo(s.name);
            }
            return -1;
        }
    
    }
    
    public class Test {
        public static void main(String[] args) {
    
            TreeSet<Object> ts = new TreeSet<>();
            ts.add(new Teacher("Jack", 19));
            ts.add(new Teacher("Rose", 18));
            ts.add(new Teacher("Tom", 19));
            ts.add(new Teacher("Rose", 18));
    
            System.out.println(ts);
            }
        }
    
    

    运行结果:

    [Rose:18, Jack:19, Tom:19]
    
    • 定制排序

    TreeSet集合中的字符串可以按照长度而不是英文字母来进行排序,可以通过在创建TreeSet集合是就自定义一个比较器来对元素进行定制排序。

    按字符串长度排序,如下:

    package com.sgl;
    
    import java.util.Comparator;
    import java.util.TreeSet;
    
    class MyComparator implements Comparator{
        @Override
        public int compare(Object obj1, Object obj2) {      //定制排序方式
            String s1 = (String) obj1;
            String s2 = (String) obj2;
            int temp = s1.length() - s2.length();
            return temp;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
    
            //创建集合时,传入Comparator接口实现定制排序规则
            TreeSet<Object> ts = new TreeSet<>(new MyComparator());
            ts.add("Jack");
            ts.add("Helena");
            ts.add("Eve");
            System.out.println(ts);
            //创建集合,使用Lambda表达式定制排序规则
            TreeSet<Object> ts2 = new TreeSet<>((obj1, obj2) -> {
                String s1 = (String) obj1;
                String s2 = (String) obj2;
                return s1.length() - s2.length();
            } );
            ts2.add("Jack");
            ts2.add("Helena");
            ts2.add("Eve");
            System.out.println(ts2);
        }
        }
    
    

    运行结果:

    [Eve, Jack, Helena]
    [Eve, Jack, Helena]
    

    简述:

    使用TreeSet集合的public TreeSet(Comparator <? super E>comparator)有参构造方法,分别传入Comparable接口实现类MyComparator以及Lambda表达式两种参数方式创建了定制排序规则的TreeSet集合。

    注意:在使用TreeSet集合存储数据时**,TreeSet集合会对存入元素进行比较排序**,所以为了保证程序的正常运行,一定保证存入TreeSet集合中的元素是同一中数据类型

    更多相关内容
  • 自然排序与定制排序

    2019-09-10 17:11:46
    1.自然排序 在Java中提供了一个Comparable接口,在接口中实现了一个public int compareTo(T o);方法 该方法返回一个整数值,通过obj1.compareTo(obj2),对两个对象进行比较,如果返回值是0则表明两数相等,如果...

    1.自然排序

    在Java中提供了一个Comparable接口,在接口中定义了public int compareTo(To);抽象方法
    该方法返回一个整数值,通过obj1.compareTo(obj2),对两个对象进行比较,如果返回值是0则表明两数相等,如果返回正整数则表明obj1大于obj2,否则如果返回负整数则表明obj1小于obj2

    TreeSet会自动调用compareTo(Object obj)方法进行元素之间的排序,然后以升序排列

    在Set集合中的TreeSet章中说过,Set其实就是Map集合的特殊表现形式(value为null的集合)那么跟踪源码,下面这个add方法的注释,说明排序是通过自然排序的

        /**
         * Adds the specified element to this set if it is not already present.
         * More formally, adds the specified element {@code e} to this set if
         * the set contains no element {@code e2} such that
         * <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
         * If this set already contains the element, the call leaves the set
         * unchanged and returns {@code false}.
         *
         * @param e element to be added to this set
         * @return {@code true} if this set did not already contain the specified
         *         element
         * @throws ClassCastException if the specified object cannot be compared
         *         with the elements currently in this set
         * @throws NullPointerException if the specified element is null
         *         and this set uses natural ordering, or its comparator
         *         does not permit null elements
         */
        public boolean add(E e) {
            return m.put(e, PRESENT)==null;
        }
    

    再次跟进到put方法

    private final Comparator<? super K> comparator;
    //put方法作为添加元素和修改元素的两种功能,添加元素的时候统一返回的是null,修改元素的时候统一返回的是修改之前的元素的value。作为TreeSet方法很明显只有返回null
        public V put(K key, V value) {
            Entry<K,V> t = root;//根节点
            if (t == null) {//判断根节点是否为空
                compare(key, key); // type (and possibly null) check(检查类型可能为空)
                
                root = new Entry<>(key, value, null);//将parent赋值为null并作为根节点
                size = 1;
                modCount++;
                return null;//返回null,跳过余下代码
            }
            int cmp;
            Entry<K,V> parent;
            // split comparator and comparable paths
            Comparator<? super K> cpr = comparator;//判断comparator是定制排序还是自然排序
            //如果comparator是自然排序
            if (cpr != null) {//判断 comparator 是否为null,如果是自然顺序则为null
            	//通过循环比较key的值计算将要添加的结点的位置
                do {
                    parent = t;
                    cmp = cpr.compare(key, t.key);//如果发现有某个结点的key值和将要添加的key的值相等,说明这是修改操作,修改其value值返回旧value值
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);//如果根节点不是空
            }
            else {//如果在创建对象的时候并没有从外部传入comparator比较器
                if (key == null)//判断key的值是否为null
                    throw new NullPointerException();//如果是就抛出空指针异常
                @SuppressWarnings("unchecked")
                    Comparable<? super K> k = (Comparable<? super K>) key;
                do {
                    parent = t;
                    cmp = k.compareTo(t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            Entry<K,V> e = new Entry<>(key, value, parent);
            if (cmp < 0)
                parent.left = e;
            else
                parent.right = e;
            fixAfterInsertion(e);//调用方法重构红黑树
            size++;
            modCount++;
            return null;
        }
    

    通过上述源码解析我们很容易就发现,我们传入值到add方法中,会调用put方法,put方法将自然排序和定制排序进行了隔离,而源码中将接口Comparator设置为finale类型
    并在put方法中进行判断,
    如果是Comparator定制排序(默认排序),则可以通过key的compare排序后判断key值是否相等,如果不相等则生成数的左或右节点,相等则替换(在TreeSet中value值都为null,所以即使替换也看不出效果),
    如果是Comparable自然排序(外传入排序(因为包装类或String类型中都写有自然排序方法,如下代码)),那么private final Comparator<? super K> comparator;就会是null,则cpr就是null,那么程序就会执行自然排序,排序并在不相等的情况下生成树的左或右子节点,相等则替换
    最后重构红黑树

        public int compareTo(String anotherString) {
            int len1 = value.length;
            int len2 = anotherString.value.length;
            int lim = Math.min(len1, len2);
            char v1[] = value;
            char v2[] = anotherString.value;
    
            int k = 0;
            while (k < lim) {
                char c1 = v1[k];
                char c2 = v2[k];
                if (c1 != c2) {
                    return c1 - c2;
                }
                k++;
            }
            return len1 - len2;
        }
    

    看完String类中重写的Comparable接口中的compareTo方法后就会更加容易理解,为什么注释中会说是通过自然排序了
    因为这是为了使对象通过一个默认的顺序进行排序,如果是已经定义好的(如:String、Integer等)
    所有添加的数据都按照这个顺序进行排序,则称为自然排序

    但是我们发现一个问题,即我们传入的值之间必须是需要进行比较的
    那么问题来了,如果传入相同的对象确实,可以很容易的通过某种规则进行比较,但是不同的对象呢?
    

    代码如下

    package TreeSetTest;
    
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1 {
    	public static void main(String[] args) {
    		TreeSet ts=new TreeSet();
    		ts.add(new String());
    		ts.add(new Date());
    	}
    }
    

    会出现java.lang.String cannot be cast to java.util.Date的错误,无法从String转换成Date,在String类中的compareTo方法中对应的形参是该类对象,如果传入一个Date类的对象,对象之间会发生强制转换,而我们知道,这样是并不能发生转换的

    package TreeSetTest;
    
    import java.util.Date;
    import java.util.TreeSet;
    //这样又是可以的了
    public class Test1 {
    	public static void main(String[] args) {
    		TreeSet ts=new TreeSet();
    		ts.add(new String());
    		ts.add(new String());
    
    	}
    }
    
    所以在TreeSet中是必须要求对象是相同的并且自然排序需要写在对象所在的类中(因为是外传入排序)
    

    2.定制排序

    定制排序是使用的java中提供的Comparator接口,自然排序就是说排序发生在封装类中,用户无法使用,但是定制排序是可以通过用户自己实现的,在创建TreeSet对象时就可以自定义Comparator接口中的int compare(T o1,To2)方法,比较两个参数的大小,如果该方法返回正整数则表明o1大于o2,如果返回0则说明o1=o2,如果返回负整数则说明o1小于o2

    整数类型

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator(){
    			@Override
    			public int compare(Object o1,Object o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return -(p1.getAge()-p2.getAge());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小明","女"));
    		System.out.println(ts);
    	}
    }
    
    

    输出如下

    [Person [age=17, name=小明, sex=女], Person [age=15, name=小明, sex=男]]
    

    String类型

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator(){
    			@Override
    			public int compare(Object o1,Object o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return p1.getName().compareTo(p2.getName());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小红","女"));
    		System.out.println(ts);
    	}
    }
    

    输出结果:

    [Person [age=15, name=小明, sex=男], Person [age=17, name=小红, sex=女]]
    

    当字符串相同情况

    说明:这里在比较值相等的情况,是添加无效的,有人会说map中为什么可以覆盖,那是因为key值并没有变,而是修改了Value值,而在TreeSet中的值都是key值,value为null值,所以TreeSet中出现相同值是不会报错也不会被替换的

    如下测试:

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator<Person>(){
    			@Override
    			public int compare(Person o1, Person o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return p1.getName().compareTo(p2.getName());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小明","女"));
    		System.out.println(ts);
    	}
    }
    

    输出结果:

    [Person [age=15, name=小明, sex=男]]
    

    这里我们需要注意的是,数值是可以直接减的,但是字符串等类类型通过调用自然排序的方法是最简单有效的,至于是升序还是降序,前面加负号即可

    展开全文
  • 本教程特点: 1.更适合零基础学员: ·自Java语言起源始,循序渐进,知识点剖析细致且每章配备大量随堂练习,让你步步为营,学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学,宋老师语言生动幽默,举例形象生动深入浅...
  • 自然排序和定制排序

    2020-10-04 17:20:19
    定制排序:实现接口comparator的compare()方法。 配置函数方法 public class Phone implements Comparable{ private int age; private String name; public Phone(){ } public Phone(String name,int age){ ...

    自然排序:继承接口comparable实现方法compareTo()方法。
    定制排序:实现接口comparatorcompare()方法。

    配置函数方法

    public class Phone implements Comparable{
        private int age;
        private String name;
    
        public Phone(){
    
        }
    
        public Phone(String name,int age){
            this.name = name;
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
      @Override
        public int compareTo(Object o) {
            if(o instanceof Phone){
                Phone phone = (Phone)o;
                int compare = this.name.compareTo(phone.name);
                if(compare != 0){
                    return compare;
                }else{
                    return this.age - phone.age;
                }
            }else{
                throw new RuntimeException("输入的类型不匹配");
            }
        }
    }
    

    使用方法

    public class TestTreeSet {
    
        // 自然排序
        @Test
        public void test1(){
            TreeSet ts = new TreeSet();
    /*        ts.add(45);
            ts.add(-8);
            ts.add(95);
            ts.add(0);*/
    
            ts.add(new Phone("Tom",15));
            ts.add(new Phone("Jack",15));
            ts.add(new Phone("Bob",15));
            ts.add(new Phone("Jerry",15));
            ts.add(new Phone("Tom",23));
    
    
            Iterator iterator = ts.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    
        // 定制排序。
        @Test
        public void test2(){
            Comparator com = new Comparator() {
                @Override
                public int compare(Object o1, Object o2) {
                    if(o1 instanceof Phone && o2 instanceof Phone){
                        Phone p1 = (Phone)o1;
                        Phone p2 = (Phone)o2;
                        int compareP = p1.getName().compareTo(p2.getName());
                        if(compareP != 0){
                            return compareP;
                        }else{
                            return Integer.compare(p1.getAge(),p2.getAge());
                        }
                    }else{
                        throw new RuntimeException("输入的数据类型不匹配");
                    }
                }
            };
            TreeSet ts = new TreeSet(com);
            ts.add(new Phone("Tom",15));
            ts.add(new Phone("Jack",15));
            ts.add(new Phone("Bob",15));
            ts.add(new Phone("Jerry",15));
            ts.add(new Phone("Tom",23));
    
    
            Iterator iterator = ts.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    }
    
    
    展开全文
  • 比较器(Comparable和Comparator)、自然排序、定制排序

    千次阅读 多人点赞 2019-11-07 19:53:53
    比如Integer,double等基本类型数据,Java可以对他们进行比较排序,但是在 Java 中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题 。这篇博客对比较器进行了详细的说明并配有完整的代码实现。

    写在前面: 我是「扬帆向海」,这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。

    这博客是对自己学习的一点点总结及记录,如果您对 Java算法 感兴趣,可以关注我的动态,我们一起学习。

    用知识改变命运,让我们的家人过上更好的生活

    比如Integer,double等基本类型数据,Java可以对他们进行比较排序,但是在 Java 中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题 。

    一、java中的sort()方法

    在java.util.Collections类中有个sort()方法,主要是用来给数组排序

    public class CompareTest1 {
        @Test
        public void test() {
            String[] arr = new String[]{"AA", "SS", "FF", "OO", "EE", "HH"};
            System.out.println("排序之前: " + Arrays.toString(arr));
            Arrays.sort(arr);
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    

    代码执行结果:

    排序之前: [AA, SS, FF, OO, EE, HH]
    排序之后: [AA, EE, FF, HH, OO, SS]
    

    需求:商场有一批水果,对水果的价格进行排序

    水果类:

    public class Fruit {
        private String name;
        private double price;
    
        public Fruit() {
        }
    
        public Fruit(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Fruit{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
    
    

    测试类:

    public class CompareTest2 {
        @Test
        public void test() {
            Fruit[] arr = new Fruit[5];
            arr[0] = new Fruit("apple", 18);
            arr[1] = new Fruit("pear", 6);
            arr[2] = new Fruit("banana", 14);
            arr[3] = new Fruit("watermelon", 26);
            arr[4] = new Fruit("tomato", 6);
            System.out.println("排序之前: " + Arrays.toString(arr));
            // 排序
            Arrays.sort(arr);
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    

    程序将会报错:

    java.lang.ClassCastException: xxx.Fruit cannot be cast to java.lang.Comparable
    

    报错原因:类型转换错误

    为了解决这个错误,对象之间的排序将用到比较器。

    Java 实现对象排序的方式有两种:

    自然排序: java.lang.Comparable

    定制排序: java.util.Comparator

    二、自然排序:Comparable

    1.自然排序的定义

    Comparable 接口强行对实现它的每个类的对象进行整体排序

    2.实现过程

    实现 Comparable接口的类必须实现 compareTo(Object obj) 方法,两个对象通过 compareTo方法的返回值来比较大小 。
    ① 如果当前对象 this 大于形参对象 obj 则返回正整数;
    ② 如果当前对象 this 小于 形参对象 obj则返回 负整数;
    ③ 如果当前对象 this 等于 形参对象 obj 则返回零 。
    实现 Comparable接口的对象列表(和数组)可以通过 Collections.sort 或 Arrays.sort 进行自动排序。
    实现此接口的对象可以用作有序映射中的键或有序集合中的集合,无需指定比较器

    为了解决类型转换错误,在水果类里面实现Comparable接口。

    3.示例代码

    水果类:

    public class Fruit implements Comparable<Fruit> {
        private String name;
        private double price;
    
        public Fruit() {
        }
    
        public Fruit(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Fruit{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    
        // 水果价格从低到高进行排序,若价格相同则按水果名称从高到低排序
        @Override
        public int compareTo(Fruit fruit) {
            if (this.price > fruit.price) {
                return 1;
            } else if (this.price < fruit.price) {
                return -1;
            } else {
                // this.name.compareTo(fruit.name) 按名称从低到高,前面加负号,表示相反
                return -this.name.compareTo(fruit.name);
            }
        }
    }
    

    注:测试类代码同Test2
    代码执行结果:

    排序之前: [Fruit{name='apple', price=18.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='tomato', price=6.0}]
    排序之后: [Fruit{name='tomato', price=6.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='apple', price=18.0}, Fruit{name='watermelon', price=26.0}]
    

    三、定制排序 :Comparator

    在实际开发中,遇到当元素的类型实现了Comparable 接口,但是它的排序方式不适合当前的操作;或者根本没有实现Comparable
    接口,而又不方便修改代码。那么可以考虑使用 Comparator 的对象进行排序。

    1.实现过程

    定义一个比较器对象;
    重写 compare(Object o1,Object o2) 方法,比较 o1 和 o2 的大小:
    ① 如果方法返回正整数,则表示 o1 大于 o2 ;
    ② 如果方法返回 0 ,表示相等;
    ③ 如果方法返回负整数,表示o1 小于 o2 。

    可以 将 Comparator 传递给 sort 方法,从而允许在排序顺序上实现精确控制 。

    2.示例代码

    public class CompareTest3 {
        /**
         * 按字符从大到小进行排序
         */
        @Test
        public void test() {
            String[] arr = new String[]{"AA", "CC", "KK", "MM", "GG", "FF", "DD"};
            System.out.println("原来的字符串: " + Arrays.toString(arr));
            Arrays.sort(arr, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return -o1.compareTo(o2);
                }
            });
            System.out.println("按字符从大到小排序后的字符串: " + Arrays.toString(arr));
        }
    }
    
    

    代码执行结果:

    原来的字符串: [AA, CC, KK, MM, GG, FF, DD]
    按字符从大到小排序后的字符串: [MM, KK, GG, FF, DD, CC, AA]
    

    对水果的价格进行排序

    注:水果类同前,节省篇幅,在此不再重复。

    public class CompareTest4 {
        @Test
        public void test() {
            Fruit[] arr = new Fruit[5];
            arr[0] = new Fruit("apple", 18);
            arr[1] = new Fruit("pear", 6);
            arr[2] = new Fruit("banana", 14);
            arr[3] = new Fruit("watermelon", 26);
            arr[4] = new Fruit("watermelon", 6);
            System.out.println("排序之前: " + Arrays.toString(arr));
    
            Arrays.sort(arr, new Comparator<Fruit>() {
                // 按照水果名称从低到高排序,若名称相同则按照价格从高到低排序
                @Override
                public int compare(Fruit o1, Fruit o2) {
                    if (o1.getName().equals(o2.getName())) {
                        return -Double.compare(o1.getPrice(), o2.getPrice());
                    } else {
                        return o1.getName().compareTo(o2.getName());
                    }
                }
            });
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    
    

    代码执行结果:

    排序之前: [Fruit{name='apple', price=18.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='watermelon', price=6.0}]
    排序之后: [Fruit{name='apple', price=18.0}, Fruit{name='banana', price=14.0}, Fruit{name='pear', price=6.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='watermelon', price=6.0}]
    
    

    当定制排序和自然排序同时存在时,最终的排序结果是按照定制排序进行排序的。

    上一篇 聊聊 StringBuffer 与 StringBuilder

    展开全文
  • JAVA中的自然排序以及定制排序 自然排序: 需要实现comparable接口,重写接口中的compareTo方法。实现此接口的对象列表(和数组)可以通过Collections.sort(和 Arrays.sort)进行自动排序 compareTo方法返回值为int...
  • Java自然排序与定制排序

    千次阅读 2020-01-10 20:25:57
    一、自然排序 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 如果当前对象this大于形参对象obj,则返回正整数;如果当前对象this小于形参对象obj,则返回负整数;如果当前对象this等于参数...
  • 目录
  • java集合的工具类Collections中提供了两种排序的方法,分别是: Collections.sort(List list) Collections.sort(List list,Comparator c) 第一种称为自然排序,参与排序的对象需实现comparable接口,重写其compareTo()...
  • 1. 自然排序 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 //这里固定指:o1表示位于前面的对象,o2表示后面的对象,并且表示o1比o2小 o1.compareTo(o2) //升序 Collections.sort(persons, ...
  • Java基础篇自然排序和定制排序

    多人点赞 热门讨论 2022-05-13 10:46:21
    自然排序和定制排序,排序
  • **注意:**TreeSet满足Set的特点 1.不能重复存储同一个...2.跟Set不同的是以排序方式输出数据 先创建一个R.java public class R implements Comparable<R>{ private int count; public R(int count) { ...
  • TreeSet的几大特点: 1、TreeSet中存储的类型必须是一致的,不能一下存int,一下又存string 2、TreeSet在...有2种排序方法,1:自然排序 2、定制排序 自然排序:要求自定义类实现java.lang.Comparable接口并重写co...
  • * TreeMap的特点是可以进行自然排序和定制排序 */ import java.util.Comparator; import java.util.Iterator; import java.util.Set; import java.util.TreeMap; public class TreeMapTest { public static ...
  • 排 序—定制排序 TreeSet的自然排序要求元素所属的类实现Comparable接口,如果元素所属的类没 有实现Comparable接口,或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序,则考虑使用定制...
  • TreeSet的两种排序方式:自然排序和定制排序 TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态。TreeSet有两种排序方法:自然排序和定制排序。默认采用自然排序。 1. 自然排序 要求自定义类...
  • 定制排序的矩形 (20 分) 从键盘录入表示矩形个数的数字n,然后录入n个矩形的长和宽,然后对这n个矩形按照面积从大到小排序,并输出排序后的每个矩形的面积。要求:请设计Rectangle类,包含相应的构造函数和成员...
  • 定制排序与自然排序

    千次阅读 2017-04-30 10:58:04
    Set接口下主要有Hashset,LinkedhashSet,Treeset主要实现类,向treeset中添加元素的时候,需要对添加的元素进行排序,这是就需要使用java.util.Comparator和java.util.Comparable两个接口从而实现定制排序和自然排序...
  • TreeSet的自然排序和定制排序

    千次阅读 2017-07-31 07:15:49
    (该方法不能自动生成)自然排序(Comparable) TreeSet拥有的集合元素的compareTo()方法来比较元素的大小关系,然后将集合元素按照升序排列。 int compareTo(T o) 将此对象与指定的对象进行比较,以返
  • 计算机后端-Java-Java核心基础-第24章 集合01 26. TreeSet的定制排序.avi
  • java Set接口的实现类TreeSet 自然排序 定制排序1.TreeSet 自然排序2.TreeSet 定制排序 1.TreeSet 自然排序 TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按...
  • 使用TreeSet实现定制排序 我们知道: 一、TreeSet类不但实现了Set的接口,而且还实现了所谓的的java.util.SortedSet接口,所以呢在遍历集合时会进行默认的排序,即升序排列。 eg1(Integer): package Set类; ...
  • 计算机后端-Java-Java核心基础-第22章 常用类 23. 使用Comparator实现定制排序.avi
  • 493.491.JAVA基础教程_常用类-使用Comparator实现定制排序(493).rar
  • 集合TreeSet(自然排序与定制排序

    千次阅读 2017-12-28 15:30:48
    一、TreeSet的自然排序: 步骤: 1.让元素自身具备比较性, 2.实现Compareable接口,覆盖其CompareTo方法  例: class Student implementsComparable//第一:实现Compareable接口 {  ...
  • import java.util.Comparator; import java.util.TreeMap; public class Demo3 { public static void main(String[] args) { System.out.println(&...使用自然排序:"); TreeMap treeMap=new TreeMap
  • Arrarys.sort()是用于给数组排序的,默认的情况下,是顺序排序,即从小到大: public class Test5 { public static void main(String[] args) { int[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(arr...
  • } } /* * 【Time】2020年8月28日 上午9:52:21 * 【Function】 */ public class JDK8Practice { /** * * 调用Collections.sort()方法,通过定制排序比较两个Employee(先按年龄比,年龄相同按照姓名(ASCII码)比),...
  • 一、对二维数组进行排序 /** 注意compare 排序中默认升序: 返回 1 == true 代表降序,我想调整顺序 返回 -1 代表升序 */ Arrays.sort(arrays, new Comparator<int[]>() { @Override public int compare...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,112
精华内容 38,844
关键字:

定制排序