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

    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

    2009-07-13 12:02:00
    Comparator comparator=new Comparator(){ public int compare(Object o1, Object o2) { // TODO Auto-generated method stub return 0; } };

    Comparator comparator=new Comparator(){

      public int compare(Object o1, Object o2) {
       // TODO Auto-generated method stub
       return 0;
      }
      
     };

    展开全文
  • Comparator接口实现排序

    万次阅读 多人点赞 2017-12-22 11:21:38
    Interface Comparator<T> 对任意类型集合对象进行整体排序,排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序. 实现int compare(T o1, T o2);方法,返回正数,零,...
    Interface Comparator<T>
    

    对任意类型集合对象进行整体排序,排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序.
    实现int compare(T o1, T o2);方法,返回正数,零,负数各代表大于,等于,小于。

    单一条件排序:

    举例:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30));	
    				add(new Student("李四", 20));	
    				add(new Student("王五", 60));	
    			}
    		};
    		// 1.对学生集合按年龄进行排序
    		Collections.sort(stus, new Comparator<Student>() {
    
    			@Override
    			public int compare(Student s1, Student s2) {
    				// 升序
    				//return s1.getAge()-s2.getAge();
    				return s1.getAge().compareTo(s2.getAge());
    				// 降序
    				// return s2.getAge()-s1.getAge();
    				// return s2.getAge().compareTo(s1.getAge());
    			}
    		});
    		
    		// 2.对学生集合按姓名首字母排序
    		Comparator comparator = Collator.getInstance(Locale.CHINA);
    		Collections.sort(stus, new Comparator<Student>() {
    		
    			@Override
    			public int compare(Student s1, Student s2) {
    				return comparator.compare(s1.getName(), s2.getName());
    			}
    		
    		});
    		
    		// 输出结果
    		...
    		
    

    注: 还可以使用lambda表达式简化代码, 前提是JDK8开发环境, 如下:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30));	
    				add(new Student("李四", 20));	
    				add(new Student("王五", 60));	
    			}
    		};
    		//对学生集合按年龄进行排序
    		Collections.sort(stus, (s1,s2)->(s1.getAge()-s2.getAge()));
    

    lambda表达式是JDK8新特性之一, 允许你通过表达式来代替功能接口; 细节请自行百度… 我也是刚接触, 啊哈哈, 不熟悉,谅解谅解

    多条件排序:

    举例:

    		List<Student> stus = new ArrayList<Student>(){
    			{
    				add(new Student("张三", 30, 1));	
    				add(new Student("李四", 20, 2));	
    				add(new Student("王五", 40, 3));	
    				add(new Student("赵六", 30, 4));	
    				add(new Student("陈七", 40, 5));	
    				add(new Student("周八", 20, 6));	
    			}
    		};
    		Collections.sort(stus,new Comparator<Student>() {
    
    			@Override
    			public int compare(Student s1, Student s2) {
    				int flag;
    				// 首选按年龄升序排序
    				flag = s1.getAge()-s2.getAge();
    				if(flag==0){
    					// 再按学号升序排序
    					flag = s1.getNum()-s2.getNum();
    				}
    				return flag;
    			}
    		});
    		
    		System.out.println("年龄       学号       姓名  ");
    		for(Student s : stus){
    			System.out.println(s.getAge()+"   "+s.getNum()+"   "+s.getName());
    		}
    

    输出结果:
    这里写图片描述

    自定义条件排序

    		String[] order = {"语文","数学","英语","物理","化学","生物","政治","历史","地理","总分"};
    		final List<String> definedOrder = Arrays.asList(order);
    		List<String> list = new ArrayList<String>(){
    			{
    				add("总分");
    				add("英语");
    				add("政治");
    				add("总分");
    				add("数学");
    			}
    		};
    		Collections.sort(list,new Comparator<String>() {
    
    			@Override
    			public int compare(String o1, String o2) {
    				int io1 = definedOrder .indexOf(o1);
    				int io2 = definedOrder .indexOf(o2);
    				return io1-io2;
    			}
    		});
    		
    		for(String s:list){
    			System.out.print(s+"   ");
    		}
    

    使用lambda表达式简化代码:

    Collections.sort(list, (o1, o2)->(definedOrder .indexOf(o1)-definedOrder .indexOf(o2)));
    

    输出结果:
    这里写图片描述

    展开全文
  • 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 ...
  • 学习Comparator

    2020-08-10 16:01:50
    Comparator详解
  • Comparator接口

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

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

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

    2017-07-13 23:04:27
    ArrayList提供sort方法,可以方便的进行排序,要求输入一个Comparator类作为参数。 这个Comparator就是进行排序比较的标准。它实现接口Comparator,重载compare方法,举例如下: class Work{ int start; int end...
  • java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法...
  • 【java】Comparator的用法

    万次阅读 多人点赞 2017-02-15 00:50:52
    comparator 是javase中的接口,位于java.util包下,javase中的所有接口抽象度都很高,有必要重视 2. 网上太多的文章告诉大家comparator是用来排序;确实,可以用来排序,但不仅限于排序 3. 工作中实际需求出现很...
  • 使用外部比较器Comparator进行排序 当我们需要对集合的元素进行排序的时候,可以使用java.util.Comparator创建一个比较器来进行排序。Comparator接口同样也是一个函数式接口,我们可以把使用lambda表达式。如下示例...
  • <div><p>the current comparator implementation is correct only if there is only one "isUpdating" file in the array. This can happen for example as a result of #4244, or if concurrent uploads ...
  • Comparator改写

    2016-12-27 04:29:05
    Comparator改写 MinQueue 的改写 PriorityQueue<Node> minQ = new PriorityQueue<Node>(new Comparator<Node>() { public int compare(Node n1, Node n2) { ...
  • Comparator比较器

    2020-12-05 20:05:29
    Comparator比较器 Collections工具类集中的sort() public static<T> void sort(List<T> list) public static<T> void sort(List<T> list,Comparator<? super T> c) Comparator接口...
  • 比较器Comparator

    2018-11-03 21:21:13
    Comparator接口 java中有内置的排序,Arrays.sort(),现在我有一个Student类,类中三个成员变量name,id,age,我现在想以age作为参考进行升序排序,应该如何做,很简单,只需要自己定义一个类实现Comparator接口即可 ...
  • 排序 Comparator Comparable

    2020-03-23 10:30:11
    一:Comparable:实现Comparable无参接口,重写equals()和...二:Comparator:实现Comparator有参接口,重写compare()方法 三:Comparator 与 Comparable共存时,Comparator优先 package com.mall.controllor.ale...

空空如也

1 2 3 4 5 ... 20
收藏数 17,374
精华内容 6,949
关键字:

comparator