精华内容
下载资源
问答
  • java自然排序
    千次阅读
    2016-08-21 16:11:49

    这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行排序时,如何比较两个对象的“大小”呢?这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题,JDK提供了两个接口 java.lang.Comparable 和 java.util.Comparator 。

    一、自然排序:java.lang.Comparable
      Comparable 接口中只提供了一个方法: compareTo(Object obj) ,该方法的返回值是 int 。如果返回值为正数,则表示当前对象(调用该方法的对象)比 obj 对象“大”;反之“小”;如果为零的话,则表示两对象相等。下面是一个实现了 Comparable 接口的 Student 类:
      

    public class Student implements Comparable {  
    
        private int id;  
    
        private String name;  
    
        public Student() {  
            super();  
        }  
    
        @Override  
        public int compareTo(Object obj) {  
            if (obj instanceof Student) {  
                Student stu = (Student) obj;  
                return id - stu.id;  
            }  
            return 0;  
        }  
    
        @Override  
        public String toString() {  
            return "<" + id + ", " + name + ">";  
        }  
    }  

    Student 实现了自然排序接口 Comparable ,那么我们是怎么利用这个接口对一组 Student 对象进行排序的呢?我们在学习数组的时候,使用了一个类来给整型数组排序: java.util.Arrays 。我们使用 Arrays 的 sort 方法来给整型数组排序。翻翻 API 文档就会发现, Arrays 里给出了 sort 方法很多重载形式,其中就包括 sort(Object[] obj) ,也就是说 Arryas 也能对对象数组进行排序,排序过程中比较两个对象“大小”时使用的就是 Comparable 接口的 compareTo 方法。

    public class CompareTest {  
    
        public static void main(String[] args) {  
            Student stu1 = new Student(1, "Little");  
            Student stu2 = new Student(2, "Cyntin");  
            Student stu3 = new Student(3, "Tony");  
            Student stu4 = new Student(4, "Gemini");  
    
            Student[] stus = new Student[4];  
            stus[0] = stu1;  
            stus[1] = stu4;  
            stus[2] = stu3;  
            stus[3] = stu2;  
            System.out.println(“Array: ” + Arrays.toString(stus));   
            Arrays.sort(stus);   
            System.out.println(“Sort:  ” + Arrays.toString(stus));  
        }  
    }  
    更多相关内容
  • 主要介绍了Java自然排序Comparable使用方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 自然排序与比较器排序 自然排序(Comparable) java.lang.Comparable; Comparable是一个抽象类,需要类实现它,才可以使用自然排序。 Comparable 同时是泛型,需要实现它的public int compareTo()方法. 以TreeSet举例...

    自然排序与比较器排序

    自然排序(Comparable)

    java.lang.Comparable;

    Comparable是一个抽象类,需要类实现它,才可以使用自然排序。 Comparable 同时是泛型,需要实现它的public int compareTo()方法.

    以TreeSet举例,TreeSet有两种使用排序的方法,一种是类型自带自然排序接口Comparable,如:Integer,String等,都是实现了Comparable接口,所以可以直接添加对象进TreeSet中,TreeSet通过他们本身自带的compareTo()接口实现Set的有序排序;

            //TreeSet的无参构造方法,使用了其包含的类中的Comparable接口实现排序
            TreeSet<Student> ts = new TreeSet<Student>();
            /**
             * class Student implements Comparable<Student>{
             *     private int age;
             *
             *     @Override
             *     public int compareTo(Student s) {
             *         return 0;
             *     }
             * }
             * */
            //Student类中本身没有实现Comparable接口,我们可以自定义Comparable接口,实现我们想要的排序规则。
    

    TreeSet中使用自然排序,会将当前对象和上一个对象进行比较。

        @Override
        public int compareTo(Student s) {
            //当前对象和上一个对象
            //当前对象的年龄减去上一个对象的年龄
            int num = this.age - s.age;
            //如果结果是一个整数,那么代表当前年龄大于上一个年龄,返回正数,这时候就会将当前对象添加到TreeSet中
            //因为是整数,TreeSet就默认添加到上一个元素的后面,也就是直接插入
            //这样判断就构成了升序的排序
            //如果返回的是一个负数,那么代表当前对象小于上一个对象,就会将当前对象插入到上一个对象之前,以此来保证升序
            return num;
        }
    

    如果要使TreeSet完成降序的操作(从高到底):

        @Override
        public int compareTo(Student s) {
            //当前对象和上一个对象
            //上一个对象减去当前对象,如果是整数,那么代表上一个对象大于当前对象
            int num = s.age - this.age;
            //这时候是整数,那么就会将当前的元素添加到上一个元素之后,就完成了降序的排序(从高到低)
            //如果得到的是一个负数,那么就代表上一个元素小于当前元素,所以就会将当前元素添加到上一个元素之前,以此来保证有序
            return num;
        }
    

    如果得到的结果是0呢?那么TreeSet就认为比较的两个是相同的对象,就不会进行添加操作。

    总结:自然排序接口就是通过类来实现排序接口,使得类在需要排序的地方可以直接使用类的排序方法进行排序,但这种排序方式是固定的,也就是这个类只能使用该排序方法进行排序,如果想要不同方法来对这个类进行排序就无法实现。

    比较器排序(Compareator)

    java.util.Comparator

    Comparator比较器排序,它的好处就是将类和自然排序进行了分离,在要使用到排序的时候,在创建对象的时候给它提供一个比较器即可。

    以TreeSet举例,通过匿名内部类的方法创建比较器:

            //TreeSet的有参构造方法,通过提供比较器排序来实现TreeSet的排序,这样TreeSet的实现类就无需实现自然排序接口
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
                //以匿名内部类方式在创建TreeSet对象的时候提供比较器
                @Override
                public int compare(Student s1, Student s2) {
                    //s1就是当前的对象,s2就是TreeSet中的上一个对象
                    //还是拿当前对象和上一个对象进行比较
                    int num = s1.getAge() - s2.getAge();
                    //当前对象的年龄减去上一个对象的年龄
                    //如果是正数,那么代表当前对象大于上一个对象,
                    //就会将当前对象添加到上一个对象之后,也就是直接插入到TreeSet的末尾
                    return num;
                }
            });
    

    比较器使用的升序排序(从低到高),如果想要使用降序,那么上一个对象的具体值减去当前对象的具体值即可完成降序排序,如:

            //TreeSet的有参构造方法,通过提供比较器排序来实现TreeSet的排序,这样TreeSet的实现类就无需实现自然排序接口
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
                //以匿名内部类方式在创建TreeSet对象的时候提供比较器
                @Override
                public int compare(Student s1, Student s2) {
                    //s1就是当前的对象,s2就是TreeSet中的上一个对象
                    //还是上一个对象和当前对象进行比较
                    int num = s2.getAge() - s1.getAge();
                    //当前上一个对象的年龄减去当前对象的年龄
                    //如果是正数,那么代表上一个对象大于当前对象
                    //就会将当前对象添加到上一个对象之后,也就是直接插入到TreeSet的末尾
                    //这样就实现了降序的排序
                    return num;
                }
            });
    

    同自然排序一样,如果返回的是0,那么TreeSet就认为是相同元素,就不进行添加,这就是TreeSet能实现排序和去重的要点。

    总结:比较器排序不需要类实现自然排序接口,可以通过提供比较器的方法提供比较规则,无需该类实现自然接口,也就是该类可以使用比较器来实现多种比较排序,可以使用多种排序规则进行该类的排序。也就是Comparator将比较排序算法与具体的类分离开了,这样避免了一个类只能使用一种比较排序的算法

    参考资料:[Java中的排序比较方式:自然排序和比较器排序]((6条消息) Java中的排序比较方式:自然排序和比较器排序_littledownload的博客-CSDN博客)

    展开全文
  • 给大家介绍Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是自然排序和比较器排序,文中通过实例代码介绍的很详细,有需要的朋友们可以参考借鉴。
  • Java自然排序

    千次阅读 2017-03-31 14:47:43
    这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行...

    这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行排序时,如何比较两个对象的“大小”呢?这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题,JDK提供了两个接口 java.lang.Comparable 和 java.util.Comparator 。

    一、自然排序:java.lang.Comparable
      Comparable 接口中只提供了一个方法: compareTo(Object obj) ,该方法的返回值是 int 。如果返回值为正数,则表示当前对象(调用该方法的对象)比 obj 对象“大”;反之“小”;如果为零的话,则表示两对象相等。下面是一个实现了 Comparable 接口的 Student 类:
      

    public class Student implements Comparable {  
    
        private int id;  
    
        private String name;  
    
        public Student() {  
            super();  
        }  
    
        @Override  
        public int compareTo(Object obj) {  
            if (obj instanceof Student) {  
                Student stu = (Student) obj;  
                return id - stu.id;  
            }  
            return 0;  
        }  
    
        @Override  
        public String toString() {  
            return "<" + id + ", " + name + ">";  
        }  
    }  

    Student 实现了自然排序接口 Comparable ,那么我们是怎么利用这个接口对一组 Student 对象进行排序的呢?我们在学习数组的时候,使用了一个类来给整型数组排序: java.util.Arrays 。我们使用 Arrays 的 sort 方法来给整型数组排序。翻翻 API 文档就会发现, Arrays 里给出了 sort 方法很多重载形式,其中就包括 sort(Object[] obj) ,也就是说 Arryas 也能对对象数组进行排序,排序过程中比较两个对象“大小”时使用的就是 Comparable 接口的 compareTo 方法。

    public class CompareTest {  
    
        public static void main(String[] args) {  
            Student stu1 = new Student(1, "Little");  
            Student stu2 = new Student(2, "Cyntin");  
            Student stu3 = new Student(3, "Tony");  
            Student stu4 = new Student(4, "Gemini");  
    
            Student[] stus = new Student[4];  
            stus[0] = stu1;  
            stus[1] = stu4;  
            stus[2] = stu3;  
            stus[3] = stu2;  
            System.out.println(“Array: ” + Arrays.toString(stus));   
            Arrays.sort(stus);   
            System.out.println(“Sort:  ” + Arrays.toString(stus));  
        }  
    }  
    展开全文
  • Java自然排序与定制排序

    千次阅读 2020-01-10 20:25:57
    自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 如果当前对象this大于形参对象obj,则返回正整数;如果当前对象this小于形参对象obj,则返回负整数;如果当前对象this等于参数对象obj,则返回...

    一、自然排序

    自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则

    如果当前对象this大于形参对象obj,则返回正整数;如果当前对象this小于形参对象obj,则返回负整数;如果当前对象this等于参数对象obj,则返回零。

    1.Person类

    public class Person implements Comparable<Person> {
        private Integer age;
    
        public Person(Integer age) {
            this.age = age;
        }
    
        @Override
        public int compareTo(Person person) {
            return this.age - person.age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    '}';
        }
    }
    

    2.测试

    Arrays有方法public static void sort(Object[] a)

    @Test
    public void test1() {
        Person[] peoples = new Person[4];
        peoples[0] = new Person(11);
        peoples[1] = new Person(19);
        peoples[2] = new Person(18);
        peoples[3] = new Person(10);
    
        Arrays.sort(peoples);
    
        System.out.println(Arrays.toString(peoples));
    }

    3.结果

    二、定制排序

    定制排序:java.util.Comparator

    当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码时,那么可以考虑使用Comparator的对象来排序

    1.Person类

    public class Person {
        private Integer age;
    
        public Person(Integer age) {
            this.age = age;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    '}';
        }
    }
    

    2.测试

    Arrays有方法public static <T> void sort(T[] a, Comparator<? super T> c)

    @Test
    public void test2() {
        Person[] peoples = new Person[4];
        peoples[0] = new Person( 13);
        peoples[1] = new Person(19);
        peoples[2] = new Person(17);
        peoples[3] = new Person(16);
    
        Arrays.sort(peoples, new Comparator<Person>() {
            @Override
            public int compare(Person person1, Person person2) {
                return person1.getAge() - person2.getAge();
            }
        });
    
        System.out.println(Arrays.toString(peoples));
    }

    3.结果

    展开全文
  • java排序:Comparator接口和Comparable接口的实现
  • 教程Object Ordering引用了“自然排序”的概念:If the List consists of String elements, it will be sorted intoalphabetical order. If it consists of Date elements, it will be sortedinto chronological ...
  • Sort on a string that may contain a number19个我想要一些保留自然排序order1的字符串比较函数. Java中是否有这样的内容?我在String class中找不到任何东西,Comparator class只知道两个实现.我可以自己动手(这...
  • 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 //这里固定指:o1表示位于前面的对象,o2表示后面的对象,并且表示o1比o2小 o1.compareTo(o2) //升序 Collections.sort(persons, new ...
  • 主要介绍了简单了解java自定义和自然排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java排序签名

    2018-11-06 14:44:43
    实现当前主流签名机制。 对请求参数进行排序 并添加协议key值 进行Md5加密
  • Java自然排序(个人总结-求赞)

    千次阅读 2016-07-20 10:44:34
    这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行...
  • 排序终调用的是Arrays.sort方法来完成的,所以数组自然是用Arrays.sort了,而SortedSet里面内部也有排序功能也是类似的方式的来实现的,只是内部调用了相关的方法来完成而已;SortedSet只是一个接口,实现类有很多,...
  • Java中的自然排序

    千次阅读 2019-08-06 10:49:12
    自然排序的方式有两种 一、实现Comparable接口,重写CompareTo()方法 package cn.itlaobing.action; import java.util.*; /** * 实现 Comparable接口 */ public class Student implements Comparable&...
  • 下面小编就为大家带来一篇Java Map 按key排序和按Value排序的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java使用LinkedHashMap进行分数排序的相关代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。这篇文章主要介绍了Java Map 按照Value排序的实现方法,需要的朋友可以参考下
  • 自然归并排序java

    2017-11-06 13:19:37
    自然合并的核心主要是一个Pass函数,这个函数中设置了一个array数组,来存放每一组有序元素的起始元素的下标,最后再将最后一个元素的下标+1存放为array数组的最后一个元素,这样,在后面的合并实现中会显现出这样记录的...
  • JAVA自然排序(求赞)

    千次阅读 2016-07-20 15:48:16
    这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时,比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式,但当我们对多个对象进行...
  • 主要是对java中将汉字按照拼音排序的实现代码进行了详细的分析介绍。需要的朋友可以过来参考下,希望对大家有所帮助
  • Java 自定义排序

    千次阅读 2021-12-12 18:25:20
    java sort Comparable Comparable 可以认为是一个内比较器,实现了 Comparable 接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了 Comparable 接口的类如何比较,则依赖 compareTo 方法的...
  • 主要给大家介绍了关于java排序报:Comparison method violates its general contract异常的解决方法,文中介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面来一起看看吧。
  • Java自定义排序简单总结

    千次阅读 2022-03-27 04:46:31
    默认情况下:Java实现Comparator排序是升序,即自然排序 根据参数,返回值来判断是否交换 对于a,b两个参数(a在前,b在后) jdk官方的升序基于: < return -1 > return 1 = return 0 降序就是反过来 < ...
  • 主要介绍了Java TreeSet实现学生按年龄大小和姓名排序的方法,涉及java类型转换、遍历、比较等相关操作技巧,需要的朋友可以参考下
  • 主要介绍了JAVA像SQL一样对List对象集合进行排序的实现方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 这里主要讲解的是对象排序(按某个属性或某种规则) 首先要明白,TreeSet为...TreeSet 要实现自然排序,或者说它是怎么实现自然排序的,主要还是因为,TreeSet 排序引用类型时时通过compareTo方法的返回值来判断顺...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,375
精华内容 42,550
关键字:

java自然排序