精华内容
下载资源
问答
  • Java Comparator接口

    万次阅读 2019-05-09 15:33:59
    ------------------------------------------------------...开发工具和关键技术: MyEclipse 10 和 java 撰写时间: 20190503 --------------------------------------------------------------------- Comparator...

    ---------------------------------------------------------------------

    开发工具和关键技术: MyEclipse 10 和 java

    撰写时间: 20190503

    ---------------------------------------------------------------------

    Comparator可以比较的对象类型,是比较接口。我们如果需要控制某个类的次序,而该类本身不支持排

    序(即没有实现Comparable接口),那么我们就可以建立一个“该类的比较器”来进行排

    序,这个“比较器”只需要实现Comparator接口即可。也就是说,我们可以通过实现

    Comparator来新建一个比较器,然后通过这个比较器对类进行排序。

     

    要注意的是:

    若一个类要实现Comparator接口:它一定要实现compare(T o1, T o2) 函数,但可以不实现 equals(Object obj) 函数。

    int compare(T o1, T o2) 是“比较o1和o2的大小”,其中o1指的就是第一个要比较的对象, o2指的就是第二要比的对象。 比较之后会根据大小返回值。 返回“负数”, 意味着“o1比o2小”;返回“零”,意味着“o1等于o2”;返回“正数”,意味着“o1大于o2。

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

     

    这个接口有两个方法:

    Compare :比较用啦排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数,零,或正整数。

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

    用Comparable简单, 只要实现Comparable 接口的对象直接就成为一个可以比较

    的对象,但是需要修改源代码。 用Comparator 的好处是不需要修改源代码, 而是另

    外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传

    递过去就可以比大小了, 并且在Comparator 里面用户可以自己实现复杂的可以通用

    的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。

     

    示例代码 :

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.Comparator;

    import java.util.List;

    public class ListComparatorDemo {

    public static void main(String[] args) {

    //定义一个list集合,用来存放对象,可以这样写:Collections.sort(list,new 实现类())

    List<PersonComparator> list= new ArrayList<PersonComparator>();

    list.add(new PersonComparator("小A", 23));

    list.add(new PersonComparator("小H", 21));

    list.add(new PersonComparator("小G", 13));

    list.add(new PersonComparator("小E", 24));

    list.add(new PersonComparator("小W", 43));

    list.add(new PersonComparator("小D", 25));

    //调用Collecttions.sort排序方法

    Collections.sort(list, new Comparator<PersonComparator>() {

    //复写Comparator的compara接口

    @Override

    public int compare(PersonComparator o1, PersonComparator o2) {

     

    if (o1.getAge()== o2.getAge()) {

    //名字按照拼音字母先後顺序(小到大)是o1.getName().compareTo(o2.getName)

    return o1.getName().compareTo(o2.getName());

    }

    else{

    //从小到大排序 o1 - o2

    //从大到小排序 o2 - o1

    return o1.getAge() - o2.getAge();

    }

    }

    });

    //遍历

    for (PersonComparator person : list) {

    System.out.println(person.getName() + "   " + person.getAge());

    }

    }

    }

    //创建一个类

    class PersonComparator {

    //声明成员变量

    private String name;

    private int age;

    //声明构造器

    public PersonComparator(String name, int age) {

    super();

    this.name = name;

    this.age = age;

    }

    //创建getter 和 setter 方法

    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;

    }

    }

    展开全文
  • java Comparator接口

    2017-08-26 22:28:44
    我们已经了解了如何对一个对象数组排序,前提是这些对象是实现了Comparable接口的类的实例。例如,可以对一个字符串数组排序,因为String类实现了Comparable, 而且String.compareTo方法可以按字典顺序比较字符串。 ...

    我们已经了解了如何对一个对象数组排序,前提是这些对象是实现了Comparable接口的类的实例。例如,可以对一个字符串数组排序,因为String类实现了Comparable< String>, 而且String.compareTo方法可以按字典顺序比较字符串。
    现在假设我们希望按长度递增的顺序对字符串进行排序,而不是按字典顺序进行排序。肯定不能让String类用两种不同的方式实现compareTo方法——更何况,String类也不应该有我们来改写;

    要处理这种情况,Arrays.sort方法还有第二个版本,有一个数组和一个比较器(comparator)作为参数,比较器是实现了compartor接口的实例

    public interface comparator_c<T>
    {
        int compare(T first,T second);
    
    }

    要按长度比较字符串,可以如下定义一个实现Comparator< String>的类:

    对象克隆
    本节我们会讨论Cloneable接口,这个接口指示一个类提供了一个安全的clone方法。用于克隆并不太常见,而且有关的细节技术性很强,你可能只是想稍作了解,等真正需要的时候再深入学习
    要了解克隆的具体含义,先来回忆为一个包含对象引用的变量建立副本时会发生什么。原变量和副本都是同一个对象的引用。这说明,任何一个变量改变都会影响另一个变量。

    Employee original=new Employee("John Public " ,50);
    Employee copy=original;
    copy.raiseSalary(10); //original also change original

    如果希望copy是一个新对象,他的初始状态与original相同,但是之后他们各自会有自己不同的状态,这种情况下就可以使用clone方法。

    Employee copy =original.clone();
    copy.raiseSalary(10);  //OK--original unchange

    不过并没有这么简单,clone方法是Object的一个protected方法,这说明你的代码不能直接调用这个方法。只有Employee类可以克隆Employee对象。

    展开全文
  • JAVA Comparator接口Comparator接口

    千次阅读 2019-04-18 17:17:36
    java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法...

    java的比较器有两类,分别是Comparable接口Comparator接口
    1、继承Comparable接口,并实现compareTo()方法;
    2、定义一个单独的对象比较器,继承自Comparator接口,实现compare()方法。

    在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。

    让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组,实例如下:

    class Student implements Comparable<Student>{  
        private String name;  
        private int age;  
        private float score;  
          
        public Student(String name, int age, float score) {  
            this.name = name;  
            this.age = age;  
            this.score = score;  
        }  
          
        public String toString()  
        {  
            return name+"\t\t"+age+"\t\t"+score;  
        }  
      
        @Override  
        public int compareTo(Student o) {  
            // TODO Auto-generated method stub  
            if(this.score>o.score)//score是private的,为什么能够直接调用,这是因为在Student类内部  
                return -1;//由高到底排序  
            else if(this.score<o.score)  
                return 1;  
            else{  
                if(this.age>o.age)  
                    return 1;//由底到高排序  
                else if(this.age<o.age)  
                    return -1;  
                else  
                    return 0;  
            }  
        }  
    }  
      
    public class ComparableDemo01 {  
      
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
            Student stu[]={new Student("zhangsan",20,90.0f),  
                    new Student("lisi",22,90.0f),  
                    new Student("wangwu",20,99.0f),  
                    new Student("sunliu",22,100.0f)};  
            java.util.Arrays.sort(stu);  
            for(Student s:stu)  
            {  
                System.out.println(s);  
            }  
        }  
    }  
    

    在上面的程序中,实现了Comparable接口,并重写了compareTo方法,将学生先按成绩由大到小排名,成绩相同时候按照年龄由低到高排序。

    执行的结果是

    sunliu 22 100.0
    wangwu 20 99.0
    zhangsan 20 90.0
    lisi 22 90.0

    但是在设计类的时候,可能没有考虑到让类实现Comparable接口,那么就需要用到另外的一个比较器接口Comparator。

    从上面的实例我们可以发现,compareTo(T o)只有一个参数,而Comparator接口中必须要实现的compare(T o1,T o2)就有两个参数。

    package edu.sjtu.ist.comutil;  
      
    import java.util.Comparator;  
      
    class Student {  
        private String name;  
        private int age;  
        private float score;  
          
        public Student(String name, int age, float score) {  
            this.name = name;  
            this.age = age;  
            this.score = score;  
        }  
      
        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;  
        }  
        public float getScore() {  
            return score;  
        }  
        public void setScore(float score) {  
            this.score = score;  
        }  
      
        public String toString()  
        {  
            return name+"\t\t"+age+"\t\t"+score;  
        }  
      
    }  
      
    class StudentComparator implements Comparator<Student>{  
      
        @Override  
        public int compare(Student o1, Student o2) {  
            // TODO Auto-generated method stub  
            if(o1.getScore()>o2.getScore())  
                return -1;  
            else if(o1.getScore()<o2.getScore())  
                return 1;  
            else{  
                if(o1.getAge()>o2.getAge())  
                    return 1;  
                else if(o1.getAge()<o2.getAge())  
                    return -1;  
                else   
                    return 0;  
            }  
        }  
          
    }  
      
      
    public class ComparableDemo02 {  
      
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
      
            Student stu[]={new Student("zhangsan",20,90.0f),  
                    new Student("lisi",22,90.0f),  
                    new Student("wangwu",20,99.0f),  
                    new Student("sunliu",22,100.0f)};  
            java.util.Arrays.sort(stu,new StudentComparator());  
            for(Student s:stu)  
            {  
                System.out.println(s);  
            }  
        }  
      
    }  
    
    展开全文
  • Java 可以通过 Arrays.sort() 对数组进行排序,默认是升序排列,为了能够对数组进行降序排列,需要传入重写 compare() 方法的 Comparator 接口。 需要注意的是,接口接收的参数只能是引用数据类型,无法接收基本数据...

    Java 可以通过 Arrays.sort() 对数组进行排序,默认是升序排列,为了能够对数组进行降序排列,需要传入重写 compare() 方法的 Comparator 接口。

    需要注意的是,接口接收的参数只能是引用数据类型,无法接收基本数据类型。所以需要新建引用类型数组然后将数组的值复制过去。

    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ComparatorTest {
        public static void main(String[] args) {
            int[] nums = {3, 4, 5, 1, 9, 10, 45, 93, 26};
            Arrays.sort(nums);
            // 默认升序排列
            System.out.println(Arrays.toString(nums));
            Integer[] nums1 = new Integer[nums.length];
            for(int i = 0; i < nums.length; i++)    nums1[i] = nums[i];
            // 重写 Comparator 接口的 compare 方法
            Arrays.sort(nums1, new Comparator<Integer>() {
                @Override
                public int compare(Integer a, Integer b) {
                    // a 和 b,返回正数就交换位置,否则不交换位置
                    return b - a;
                }
            });
            System.out.println(Arrays.toString(nums1));
            // lambda 表达式写法
            Arrays.sort(nums1, (a, b) -> {return a-b;});
            System.out.println(Arrays.toString(nums1));
        }
    }
    

    输出结果

    [1, 3, 4, 5, 9, 10, 26, 45, 93]
    [93, 45, 26, 10, 9, 5, 4, 3, 1]
    [1, 3, 4, 5, 9, 10, 26, 45, 93]
    
    展开全文
  • JAVA Comparator接口排序

    2019-04-27 18:12:51
    代码: import java.util.ArrayList; import java.util.Collections...import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.Random; public class Pact { ...
  • java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)...
  • 一、使用方法 重写接口中的compare方法 Comparator<... c=new java.util.Comparator<int[]>() { @Override public int compare(int[] a, int[] b) { return a[1]-b[1]; } }; 二、方法
  • Comparator是一个泛型函数式接口,T表示待比较对象的类型: @FunctionalInterface public interface Comparator<T> { } 本文将主要介绍Comparator作为函数式接口的用法。 理解下面的内容需要以下知识:函数式...
  • java comparator接口理解

    2018-05-12 15:44:41
    在工作中,碰到很多开发人员对于camparator接口理解都不深,每次做排序都要写一个main函数试一下才知道就行排序对了没。 怎么理解这个接口的行为 接口注释原文: Compares its two arguments for order. ...
  • compare(Object o1,Object o2)方法是java.util.Comparator接口的方法,它实际上用的是待比较对象的compareTo(Object o)方法。 之前一直搞不清楚自定义的compare的返回值到底怎么处理,一番查询和总结后得到如下结果...
  • 相同点 这两个接口都是用来排序的,例如数组的方法Arrays.sort(),对...Comparator接口是用来给其他类对象进行排序的,重点是给他人 。 Comparable例子 首先定义一个类实现了Comparable接口 ,类名叫Co...
  • 实现接口定义比较器 通过重写compare方法即可实现排序规则的指定。 int compare(Object t1, Object t2) 返回一个基本类型的整型 如果要按照升序排序 则t1 小于t2,返回-1(负数),相等返回0,t1大于t2返回1(正数)...
  • Java Comparator接口中compare方法使用

    千次阅读 2019-06-03 16:50:11
    经常忘记,记录一下. 首先看一下部分排序源码 //----------------------------Collections.sort------------------------------------------ ... void sort(T[] a, Comparator<? super T> c) { if ...
  • java1.8新特性之list多条件排序和Comparator接口排序 ## 一、java1.8新特性之list多条件排序 public static void main(String[] args) { String orderId1 = "2321837281372913"; String userId1 = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,557
精华内容 1,822
关键字:

javacomparator接口

java 订阅