comparator 订阅
comparator,英语单词,主要用作名词,作名词时译为“[仪] 比较仪;比测仪”。 [1] 展开全文
comparator,英语单词,主要用作名词,作名词时译为“[仪] 比较仪;比测仪”。 [1]
信息
外文名
comparator
美式发音
['kɑmpə,retɚ]
词    性
名词
英式发音
[kəm'pærətə]
comparator单词用法
柯林斯英汉双解大词典comparator /kəmˈpærətə/1.N any instrument used to measure a property of a system by comparing it with a standard system 参照标准系统以测量某系统之性能的仪器 [1] 
收起全文
精华内容
下载资源
问答
  • comparator

    2021-03-04 11:02:02
    常见的接口与类 – Comparator 目录 接口概述 接口方法详解 接口方法实践操作 正文 接口Comparator 1.1  前面我们讲过Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的...

    常见的接口与类 – Comparator
    目录

    1. 接口概述
    2. 接口方法详解
    3. 接口方法实践操作

    正文

    接口Comparator 1.1
      前面我们讲过Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较的功能,但该接口注重的却是比较容器,然后对其排序,这就是Comparator,下面我们就来具体认识一下;

    回到顶部

    1. 接口概述
        Comparator并不想Comparable那样有许许多多的实现类,该接口的实现类只有两个Collator, RuleBasedCollator,但是该接口提供的两个方法,仍然是十分有用的,下面我们就来详细通过API介绍一下接口,下节介绍接口方法;

    查看API:

    public interface Comparator
      强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序。

    当且仅当对于一组元素 S 中的每个e1和e2 而言,c.compare(e1, e2)==0与 e1.equals(e2) 具有相等的布尔值时,Comparator c 强行对 S 进行的排序才叫做与 equals 一致的排序。

    当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set(或有序映射)进行排序时,应该小心谨慎。假定一个带显式 Comparator c 的有序 set(或有序映射)与从 set S 中抽取出来的元素(或键)一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的,那么有序 set(或有序映射)将是行为“怪异的”。尤其是有序 set(或有序映射)将违背根据 equals 所定义的 set(或映射)的常规协定。 例如,假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a 和 b 添加到一个空 TreeSet 中,则第二个 add 操作将返回 true(树 set 的大小将会增加),因为从树 set 的角度来看,a 和 b 是不相等的,即使这与 Set.add 方法的规范相反。

    注:通常来说,让 Comparator 也实现 java.io.Serializable 是一个好主意,因为它们在可序列化的数据结构(像 TreeSet、TreeMap)中可用作排序方法。为了成功地序列化数据结构,Comparator(如果已提供)必须实现 Serializable。

    在算术上,定义给定 Comparator c 对给定对象 set S 实施强行排序 的关系式 为:

       {(x, y) such that c.compare(x, y) <= 0}.
    

    此整体排序的商 (quotient) 为:

       {(x, y) such that c.compare(x, y) == 0}.
    

    它直接遵循 compare 的协定,商是 S 上的等价关系,强行排序是 S 上的整体排序。当我们说 c 强行对 S 的排序是与 equals 一致 的时,意思是说排序的商是对象的 equals(Object) 方法所定义的等价关系:

       {(x, y) such that x.equals(y)}.
    

    此接口是 Java Collections Framework 的成员。

    回到顶部
    2. 接口方法详解
      作为接口Comparator提供了两个抽象方法,如下:

    int

    compare(T o1, T o2) 比较用来排序的两个参数。

    boolean

    equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。

    通过API,我们来解读接口方法:

    Compare()比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 在前面的描述中,符号 sgn(expression) 表示 signum 数学函数,根据 expression 的值为负数、0 还是正数,该函数分别返回 -1、0 或 1。

    实现程序必须确保对于所有的 x 和 y 而言,都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。(这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。)
    实现程序还必须确保关系是可传递的:((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0。
    最后,实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言,都存在 sgn(compare(x, z))==sgn(compare(y, z))。
      虽然这种情况很普遍,但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来,任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意:此 Comparator 强行进行与 equals 不一致的排序。”

    可能抛出异常ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

    Equals()指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外,仅当 指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时,此方法才返回 true。因此,comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言,都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。

    注意,不重写 Object.equals(Object) 方法总是安全的。然而,在某些情况下,重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序,从而提高性能。

    覆盖: 类 Object 中的 equals

    参数: obj - 要进行比较的引用对象。

    返回: 仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。

    回到顶部
    3. 接口方法实践操作
      上面我们对接口中的两个方法进行了一番概述,那么接下来我们就来实践操作一下这两个方法。

    复制代码
    package cn.comparator.A;
    import java.util.Comparator;
    /**
    * 我们考虑这样一种情况,那么就是一个String类型的数组,我们希望数组的排序是
    * 按照字符串的长度来排序,而不是字典书序,那么此时显然String的compareTo不适用了,
    * 并且String是final类,也不允许我们更改,那么此时该怎么做呢?
    * Arrays提供了一个用于排序的sort方法,如果不传递比较器的话,
    * 那么默认使用该类型的比较器进行比较,这里要比较的是String,String的比较器不符合我们
    * 的需求,那么最好的做法就是自己定义个比较器,然后传递进去,下面来试一下
    /
    public class ComparatorLength implements Comparator{
    /
    *
    * 如果参数1的长度大于参数2的长度,那么返回1,否则返回-1
    */
    @Override
    public int compare(String o1, String o2) {
    int len1 = o1.length();
    int len2 = o2.length();
    return (len1 - len2 > 0) ? 1 : -1;
    }
    }
    复制代码
    复制代码
    @Test
    public void test2(){
    String[] str = {“aadsaf”,“dqwd”,“dqwfcsqc”,“xqsccaac”,“csfwffqaf”,“czxca”,“cas”,“cacs”,“casc”};
    Comparator com1 = new ComparatorLength();
    Comparator com2 = new ComparatorLength();
    Arrays.sort(str, com1);
    System.out.println(Arrays.toString(str));
    Arrays.sort(str, com2);
    System.out.println(Arrays.toString(str));
    System.out.println((com1 == com2) +"–"+ (com1.equals(com2)));
    }
    复制代码

    上面我们简单对Comparator的方法进行了实践,那么我们考虑对数组进行更详细的排序,按照字符排序,并且重写equals方法,注意equals方法是重写Object的,Comparator虽然具有equals,但是使用Eclipse快捷重写该方法时,没有任何提示,下面我们来看一下:

    复制代码
    package cn.comparator.A;
    import java.util.Comparator;
    public class ComparatorLeng implements Comparator{
    /**
    * 比较字符串元素
    */
    @Override
    public int compare(String o1, String o2) {
    return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
    Comparator com = (Comparator) o;
    return this.compare(o1, o2) == com.compare(o1, o2);
    }
    }
    复制代码
    复制代码
    @Test
    public void test3(){
    String[] str = {“aadsaf”,“dqwd”,“dqwfcsqc”,“xqsccaac”,“csfwffqaf”,“czxca”,“cas”,“cacs”,“casc”};
    Comparator com1 = new ComparatorLeng();
    Comparator com2 = new ComparatorLeng();
    Arrays.sort(str, com1);
    System.out.println(Arrays.toString(str));
    Arrays.sort(str, com2);
    System.out.println(Arrays.toString(str));
    System.out.println((com1 == com2) +"–"+ (com1.equals(com2)));
    }
    复制代码

    我们看到实现了既定操作,我们考虑一下,我们是学习过排序算法的,那么试验一下:

    复制代码
    package cn.comparator.A;
    import java.util.Comparator;
    public class ComparatorLeng implements Comparator{
    String o1 = “sacWDVWdvWDSCDXCsfsdf”;
    String o2 = “FWEFxsafcsdavxFWEFVcss”;
    /**
    * 比较字符串元素
    */
    @Override
    public int compare(String o1, String o2) {
    return o1.compareTo(o2);
    }
    @Override
    public boolean equals(Object o) {
    Comparator com = (Comparator) o;
    return this.compare(o1, o2) == com.compare(o1, o2);
    }
    public Comparable[] sort(Comparable[] arr){
    //将数组按照升序排列
    int len = arr.length;
    for (int i = 0; i < len; i++) {
    //将arr[i]插入到arr[i-1],arr[i-2]…之中去
    for (int j = i; j > 0 && less(arr[j], arr[j-1]); j–) {
    //交换arr[j]和arr[j-1]元素
    exch(arr, j, j-1);
    }
    }
    return arr;
    }
    //比较数组元素
    public boolean less(Comparable c1,Comparable c2){
    return c1.compareTo(c2) < 0;
    }
    //交换元素
    public void exch(Comparable[] com, int i,int j){
    Comparable ce = com[i];
    com[i] = com[j];
    com[j] = ce;
    }
    }
    复制代码
    复制代码
    @Test
    public void test4(){
    String[] str = {“aadsaf”,“dqwd”,“dqwfcsqc”,“xqsccaac”,“csfwffqaf”,“czxca”,“cas”,“cacs”,“casc”};
    String[] str1 = {“aadsaf”,“dqwd”,“dqwfcsqc”,“xqsccaac”,“csfwffqaf”,“czxca”,“cas”,“cacs”,“casc”};
    ComparatorLeng com1 = new ComparatorLeng();
    str = (String[]) com1.sort(str);
    System.out.println(Arrays.toString(str));
    Arrays.sort(str1, com1);
    System.out.println(Arrays.toString(str1));
    }
    复制代码

    综上,我们简单了解了Comparator的方法,我们会在以后的学习中进行加强学习,这个是后话了;

    展开全文
  • Comparator

    2020-11-03 20:24:12
    Arrays.sort(people,Comparator.comparing(Person::getName); 可以把比较器与thenComparing方法串起来,来处理比较结果相同的情况: Arrays.sort(people,Comparator.comparing(Person::getLasrName).thenComparing...

    按名字对对象数组进行排序:

    Arrays.sort(people,Comparator.comparing(Person::getName);
    

    可以把比较器与thenComparing方法串起来,来处理比较结果相同的情况:

    Arrays.sort(people,Comparator.comparing(Person::getLasrName).thenComparing(Person::getFirstName));
    

    根据人名长度完成排序:

    Arrays.sort(people,Comparator.comparing(Person::getName,(s,t)->Integer.compare(s.length(),t.length())));
    

    要完成上面的操作,还有一种更容易的做法:

    Arrays.sort(people,Comparator.comparingInt(p->p.getName().length()));
    
    展开全文
  • Comparator详解

    万次阅读 多人点赞 2018-12-26 21:08:09
    实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较的功能,但该接口注重的却是比较容器,然后对其排序,这就是Comparator,下面我们就来具体认识一下。 1. 接口概述  Comparator并不想...

    前面我们讲过Java提供了一个用于比较的接口Comparable,提供了一个比较的方法,所有实现该接口的类,都动态的实现了该比较方法。实际上Java中除了比较一个接口外,还提供了一个接口,该接口也是具有比较的功能,但该接口注重的却是比较容器,然后对其排序,这就是Comparator,下面我们就来具体认识一下。

    1. 接口概述

      Comparator并不想Comparable那样有许许多多的实现类,该接口的实现类只有两个Collator, RuleBasedCollator,但是该接口提供的两个方法,仍然是十分有用的,下面我们就来详细通过API介绍一下接口,下节介绍接口方法;

    查看API:

    public interface Comparator<T>

      强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的顺序,或者为那些没有自然顺序的对象 collection 提供排序。

      当且仅当对于一组元素 S 中的每个e1和e2 而言,c.compare(e1, e2)==0与 e1.equals(e2) 具有相等的布尔值时,Comparator c 强行对 S 进行的排序才叫做与 equals 一致的排序。

      当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set(或有序映射)进行排序时,应该小心谨慎。假定一个带显式 Comparator c 的有序 set(或有序映射)与从 set S 中抽取出来的元素(或键)一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的,那么有序 set(或有序映射)将是行为“怪异的”。尤其是有序 set(或有序映射)将违背根据 equals 所定义的 set(或映射)的常规协定。 例如,假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a 和 b 添加到一个空 TreeSet 中,则第二个 add 操作将返回 true(树 set 的大小将会增加),因为从树 set 的角度来看,a 和 b 是不相等的,即使这与 Set.add 方法的规范相反。

      注:通常来说,让 Comparator 也实现 java.io.Serializable 是一个好主意,因为它们在可序列化的数据结构(像 TreeSet、TreeMap)中可用作排序方法。为了成功地序列化数据结构,Comparator(如果已提供)必须实现 Serializable。

    在算术上,定义给定 Comparator c 对给定对象 set S 实施强行排序 的关系式 为:

           {(x, y) such that c.compare(x, y) <= 0}.

    此整体排序的商 (quotient) 为:

           {(x, y) such that c.compare(x, y) == 0}.

      它直接遵循 compare 的协定,商是 S 上的等价关系,强行排序是 S 上的整体排序。当我们说 c 强行对 S 的排序是与 equals 一致 的时,意思是说排序的商是对象的 equals(Object) 方法所定义的等价关系:

           {(x, y) such that x.equals(y)}.

    此接口是 Java Collections Framework 的成员。

    2. 接口方法详解

      作为接口Comparator提供了两个抽象方法,如下:

    int

    compare(T o1, T o2) 比较用来排序的两个参数。

     boolean

    equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。

      通过API,我们来解读接口方法:

      Compare()比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。 在前面的描述中,符号 sgn(expression) 表示 signum 数学函数,根据 expression 的值为负数、0 还是正数,该函数分别返回 -1、0 或 1。

    • 实现程序必须确保对于所有的 x 和 y 而言,都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。(这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。)
    • 实现程序还必须确保关系是可传递的:((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0。
    • 最后,实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言,都存在 sgn(compare(x, z))==sgn(compare(y, z))。

      虽然这种情况很普遍,但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来,任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意:此 Comparator 强行进行与 equals 不一致的排序。”

        可能抛出异常ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

      Equals()指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外,仅当 指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时,此方法才返回 true。因此,comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言,都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。

      注意,不重写 Object.equals(Object) 方法总是安全的。然而,在某些情况下,重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序,从而提高性能。

    覆盖: 类 Object 中的 equals

    参数: obj - 要进行比较的引用对象。

    返回: 仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。

    3. 接口方法实践操作

      上面我们对接口中的两个方法进行了一番概述,那么接下来我们就来实践操作一下这两个方法。

    package cn.comparator.A;
    import java.util.Comparator;
    /**
         * 我们考虑这样一种情况,那么就是一个String类型的数组,我们希望数组的排序是
         * 按照字符串的长度来排序,而不是字典书序,那么此时显然String的compareTo不适用了,
         * 并且String是final类,也不允许我们更改,那么此时该怎么做呢?
         * Arrays提供了一个用于排序的sort方法,如果不传递比较器的话,
         * 那么默认使用该类型的比较器进行比较,这里要比较的是String,String的比较器不符合我们
         * 的需求,那么最好的做法就是自己定义个比较器,然后传递进去,下面来试一下
         */
    public class ComparatorLength implements Comparator<String>{
        /**
         * 如果参数1的长度大于参数2的长度,那么返回1,否则返回-1
         */
        @Override
        public int compare(String o1, String o2) {
            int len1 = o1.length();
            int len2 = o2.length();
            return (len1 - len2 > 0) ? 1 : -1;
        }
    }
    @Test
        public void test2(){
            String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
            Comparator com1 = new ComparatorLength();
            Comparator com2 = new ComparatorLength();
            Arrays.sort(str, com1);
            System.out.println(Arrays.toString(str));
            Arrays.sort(str, com2);
            System.out.println(Arrays.toString(str));
            System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
        }

     

      上面我们简单对Comparator的方法进行了实践,那么我们考虑对数组进行更详细的排序,按照字符排序,并且重写equals方法,注意equals方法是重写Object的,Comparator虽然具有equals,但是使用Eclipse快捷重写该方法时,没有任何提示,下面我们来看一下:

     

    package cn.comparator.A;
    import java.util.Comparator;
    public class ComparatorLeng implements Comparator<String>{
        /**
         * 比较字符串元素
         */
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
        @Override
        public boolean equals(Object o) {
            Comparator com = (Comparator) o;
            return this.compare(o1, o2) == com.compare(o1, o2);
        }
    }

     

    @Test
        public void test3(){
            String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
            Comparator com1 = new ComparatorLeng();
            Comparator com2 = new ComparatorLeng();
            Arrays.sort(str, com1);
            System.out.println(Arrays.toString(str));
            Arrays.sort(str, com2);
            System.out.println(Arrays.toString(str));
            System.out.println((com1 == com2) +"--"+ (com1.equals(com2)));
        }

     

     

    我们看到实现了既定操作,我们考虑一下,我们是学习过排序算法的,那么试验一下:

     

    package cn.comparator.A;
    import java.util.Comparator;
    public class ComparatorLeng implements Comparator<String>{
        String o1 = "sacWDVWdvWDSCDXCsfsdf";
        String o2 = "FWEFxsafcsdavxFWEFVcss";
        /**
         * 比较字符串元素
         */
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
        @Override
        public boolean equals(Object o) {
            Comparator com = (Comparator) o;
            return this.compare(o1, o2) == com.compare(o1, o2);
        }
        public Comparable[] sort(Comparable<String>[] arr){
            //将数组按照升序排列
            int len = arr.length;
            for (int i = 0; i < len; i++) {
                //将arr[i]插入到arr[i-1],arr[i-2]....之中去
                for (int j = i; j > 0 && less(arr[j], arr[j-1]); j--) {
                    //交换arr[j]和arr[j-1]元素
                    exch(arr, j, j-1);
                }
            }
            return arr;
        }
        //比较数组元素
        public boolean less(Comparable c1,Comparable c2){
            return c1.compareTo(c2) < 0;
        }
        //交换元素
        public void exch(Comparable[] com, int i,int j){
            Comparable ce = com[i];
            com[i] = com[j];
            com[j] = ce;
        }
    }

     

    @Test
        public void test4(){
            String[] str = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
            String[] str1 = {"aadsaf","dqwd","dqwfcsqc","xqsccaac","csfwffqaf","czxca","cas","cacs","casc"};
            ComparatorLeng com1 = new ComparatorLeng();
            str = (String[]) com1.sort(str);
            System.out.println(Arrays.toString(str));
            Arrays.sort(str1, com1);
            System.out.println(Arrays.toString(str1));
        }

     

    特别注意:首先,排序并不是完全由三个返回值0,-1,1三个数字决定的,可以通过修改测试代码的两个参数o1和o2的位置,即原来o1 > o2改成o2 > o1,返回值不变,排序就乱了。我的理解是返回值决定位置是否需要调整,谁的位置呢?o1和o2,o1和o2是有顺序的,理解这点很重要,也就是o1排在o2后面(原数组),这样o1 > o2如果返回-1表示位置需要调整,即倒序(因为值大的o1要排到值小的o2前面去);同理,如果o2 > o1如果返回-1也表示位置需要调整,这时候变成升序了(因为值大的o2要排到值小的o1后面去)

    多个条件排序示例如下:

    一、需求

        假设现在有个如此的需求:需要对一个这样的雇员列表进行排序,排序规则如下:
        1、首先级别最高的排在前面,
        2、如果级别相等,那么按工资排序,工资高的排在前面,
        3、如果工资相当则按入职年数排序,入职时间最长的排在前面。

    雇员对象包含级别、工资和入职年份,代码如下:

       

    package com.lyz.sort.bean;
         
        import java.io.Serializable;
         
         
        /**
         * 雇员信息
         * @author liuyazhuang
         *
         */
        public class Employee implements Serializable {
         
            private static final long serialVersionUID = 4775629632953317597L;
              /**
             * ID
             */
            public int id;
            /**
             * 级别
             */
            public int level;
            /**
             * 工资
             */
            public int salary;
            /**
             * 入职年数
             */
            public int year;
         
            public int getId() {
                return id;
            }
         
            public void setId(int id) {
                this.id = id;
            }
         
            public int getLevel() {
                return level;
            }
         
            public void setLevel(int level) {
                this.level = level;
            }
         
            public int getSalary() {
                return salary;
            }
         
            public void setSalary(int salary) {
                this.salary = salary;
            }
         
            public int getYear() {
                return year;
            }
         
            public void setYear(int year) {
                this.year = year;
            }
         
            public Employee(int id, int level, int salary, int year) {
                this.id = id;
                this.level = level;
                this.salary = salary;
                this.year = year;
            }
        }

    二、实现Comparator接口

    这里我们实现Java.util.Comparator接口,用于对雇员列表进行排序,代码如下:

       

    package com.lyz.sort;
         
        import java.util.Comparator;
         
        import com.lyz.sort.bean.Employee;
         
        /**
         * 核心排序类
         * @author liuyazhuang
         *
         */
        public class EmpComparator implements Comparator<Employee> {
         
            @Override
            public int compare(Employee employee1, Employee employee2) {
                  int cr = 0;
                  //按级别降序排列
                  int a = employee2.getLevel() - employee1.getLevel();
                  if (a != 0) {
                      cr = (a > 0) ? 3 : -1;
                  } else {
                      //按薪水降序排列
                      a = employee2.getSalary() - employee1.getSalary();
                      if (a != 0) {
                          cr = (a > 0) ? 2 : -2;
                      } else {
                          //按入职年数降序排列
                          a = employee2.getYear() - employee1.getYear();
                          if (a != 0) {
                              cr = (a > 0) ? 1 : -3;
                          }
                      }
                  }
                  return cr;
            }
         
        }

    三、验证排序结果

    下面用一个单元测试,来验证排序结果是否正确

       

    package com.lyz.sort.test;
         
        import java.util.ArrayList;
        import java.util.Collections;
        import java.util.List;
         
        import org.junit.Test;
         
        import com.lyz.sort.EmpComparator;
        import com.lyz.sort.bean.Employee;
         
        /**
         * 测试排序类
         *
         * @author liuyazhuang
         *
         */
        public class SortTest {
            @Test
            public void sortTest() throws Exception {
                List<Employee> employeeList = new ArrayList<Employee>() {
                    {
                        add(new Employee(1, 9, 10000, 10));
                        add(new Employee(2, 9, 12000, 7));
                        add(new Employee(3, 5, 10000, 12));
                        add(new Employee(4, 5, 10000, 6));
                        add(new Employee(5, 3, 5000, 3));
                        add(new Employee(6, 1, 2500, 1));
                        add(new Employee(7, 5, 8000, 10));
                        add(new Employee(8, 3, 8000, 2));
                        add(new Employee(9, 1, 3000, 5));
                        add(new Employee(10, 1, 2500, 4));
                        add(new Employee(11, 2, 2000, 4));
                    }
                };
                Collections.sort(employeeList, new EmpComparator());
                System.out.println("ID\tLevel\tSalary\tYears");
                System.out.println("=============================");
                for (Employee employee : employeeList) {
                    System.out.printf("%d\t%d\t%d\t%d\n", employee.getId(), employee.getLevel(), employee.getSalary(),
                            employee.getYear());
                }
                System.out.println("=============================");
            }
        }

    运行结果:

    展开全文
  • comparator problems

    2020-12-08 21:21:12
    The problem is the comparator is overwritten in the constructor. <pre><code> javascript _.extend(this, SyncCollection.protoype); </code></pre> <p>It's clear this is supposed to mixin diff ...
  • custom comparator

    2020-12-02 23:21:05
    <div><p>Question: what would be the canonical approach to implementing a custom sort comparator for PageableCollections in Client mode? Looking to use an ignoreCase sorting fn for strings. Tried ...
  • 学习Comparator

    2020-08-10 16:01:50
  • Comparator接口实现排序

    万次阅读 多人点赞 2017-12-22 11:21:38
    Interface Comparator&amp;lt;T&amp;gt; 对任意类型集合对象进行整体排序,排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序. 实现int compare(T o1, T o2);方法,返回正数,零,...
  • 这个内部类final List ...final ListComparator comparator = new ListComparator();Collections.sort(extraContentsList, comparator);///我在bmp项目用来比较后排序,写了一个内部类class ListComparator...
  • 再谈Comparator

    2020-12-22 02:14:25
    Comparator接口包含很多方便的静态方法来创建比较器。这些方法可以用于lambda达 式或方法引用。 2. 使用方法 静态comparing方法取一个“键提取器”函数,它将类型T映射为一个可比较的 类型(如String),对要...
  • Comparator接口

    2021-01-09 17:24:43
    java.utils包下的Comparator接口。 该接口代表一个比较器,java数组工具类和集合工具类中提供对sort方法排序就是使用Comparator接口来处理排序的。 Comparator接口中有一个方法 int compare(T o1, T o2) 这个方法...
  • Comparator排序

    2019-04-04 11:41:32
    /**对trackDeploys DIY 排序*/ List<VendorTrackDeploy> trackDeploys = new ArrayList<>(); trackDeploys.sort(comparator); Comparator<... comparator = new Comparator<Vendo...
  • Comparable与Comparator浅析

    万次阅读 多人点赞 2016-03-15 19:56:41
      今天博主在翻阅TreeMap的源码,发现其键必须是实现Comparable或者Comparator的接口时产生了一些兴趣,比如在TreeMap中的put方法分别对Comparable和Comparator接口分别进行处理。那么疑问就来了,Comparable和...
  • ocr-comparator-源码

    2021-03-18 16:32:09
    ocr-comparator
  • Comparable和Comparator

    2021-02-24 15:17:41
    Comparable Comparator
  • Stream 里的 sorted 方法Streamsorted(Comparator super T> comparator);Comparator 类@FunctionalInterfacepublic interface Comparator{// 定义自己的Comparatorint compare(T o1, T o2);...// 使用comparing...
  • 重载Comparator

    2017-07-13 23:04:27
    ArrayList提供sort方法,可以方便的进行排序,要求输入一个Comparator类作为参数。 这个Comparator就是进行排序比较的标准。它实现接口Comparator,重载compare方法,举例如下: class Work{ int start; int end...
  • ComparatorAndComparable

    2015-11-03 19:37:49
    教你学会Comparator和Comparable

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,272
精华内容 8,108
关键字:

comparator