java常用类——比较器

Posted benming

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java常用类——比较器相关的知识,希望对你有一定的参考价值。

ComparableComparator接口都是为了对类进行比较,众所周知,诸如Integerdouble等基本数据类型,java可以对他们进行比较,而对于类的比较,需要人工定义比较用到的字段比较逻辑。可以把Comparable理解为内部比较器,而Comparator是外部比较器,基本的写法如下:

class Apple implements Comparable<Apple>{

    int id;

    double price;

 

    public Apple(int id, double price) {

        this.id = id;

        this.price = price;

    }

    public int compareTo(Apple o) {

        //return Double.compare(this.getPrice(),o.getPrice());

        if (Math.abs(this.price-o.price)<0.001)

            return 0;

        else

            return (o.price-this.price)>0?1:-1;

    }

    @Override

    public String toString() {

        return "Apple{" +

                "id=" + id +

                ", price=" + price +

                ‘}‘;

    }

}

class AESComparator implements Comparator<Apple>{

 

    public int compare(Apple o1, Apple o2) {

        if (Math.abs(o1.price-o2.price)<0.001)

            return 0;

        else{

            return (o1.price-o2.price)>0?1:-1;

        }

    }

}

 实现了Comparable接口的类需要实现compareTo()方法,传入一个外部参数进行比对,实现了Comparator接口的方法需要实现compare()方法,对外部传入的两个类进行比较,从而让外部方法在比较时调用。

 两者的区别是实现Comparator接口代码更加灵活,可以定义某个类的多个比较器,从而在排序时根据实际场景自由调用,而Comparable接口实现后便不能改动。

 总结:

comparator接口:真正要实现的只有compare()方法,需要单独准备出一个类来实现comparator接口,这个类将作为指定类的排序类

public int compare(Emp o1,Emp,o2){

     return o1.id - o2.id

}

这是说如果o1id - o2id是正数就升序,如果负数降序。如果0就剔除

>=1  升序

<=-1 降序

=0 重复,不记录

comparable接口

实现该类接口不需要重新创建一个排序的类,使用接口compareble接口排序,只要重写里面的compareTo()方法

Collections类是一个包装类,它包含有各种有关集合操作的静态方法。就像一个工具类。

Collections.sort()

sort()排序方法,根据元素的自然排序对指定列表按升序进行排序

public static <T>void sort(List<T> list,Comparator<>),根据指定比较器产生的顺序对指定列表进行排序,此列表内的所有元素都必须可使用指定的比较器相互比较

参数:list——要排序的列表

          C——确定列表顺序的比较器

Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题。

通常对象之间的比较可以从两个方面去看:

第一个方面:对象的地址是否一样,也就是是否引用自同一个对象。这种方式可以直接使用==“来完成。

第二个方面:以对象的某一个属性的角度去比较。

从最新的JDK8而言,有三种实现对象比较的方法:

一、覆写Object类的equals()方法;

二、继承Comparable接口,并实现compareTo()方法;

三、定义一个单独的对象比较器,继承自Comparator接口,实现compare()方法。

由于使用的排序方式的不同,具体选择哪种方法来实现对象的比较也会有所不同。

覆写equals()方法,一般用于自己实现对象数组排序的情况,而对于要使用java内置的排序算法时,使用后面两种方式都是可行的。

先来看第二种方式,这种方式就是让自己编写的类继承Comparable接口,并实现compareTo()方法,这种情况下,在使用java.util.Arrays.sort()

方法时,不用指定具体的比较器,sort()方法会使用对象自己的比较函数来完成对象的排序。下面是一个具体的例子:

[java] view plain copy

import java.util.Arrays;  

class BookCook implements Comparable<BookCook>{  

    private String title;  

    private double price;  

    public BookCook(String title,double price){  

        this.title = title;  

        this.price = price;  

    }  

    @Override  

    public String toString() {  

        return "书名:"+this.title+",价格:"+this.price;  

    }  

    @Override  

    public int compareTo(BookCook o) {  

        if(this.price > o.price){  

            return 1;  

        }else if(this.price < o.price){  

            return -1;  

        }else{  

            return 0;  

        }  

    }  

}  

一般我们使用以上两种方法就能够满足实际的开发问题。但是当出现以下情况时,就需要用到Comparator接口:

要在已经开发好的代码的基础上完善对象的比较功能时,又不想更改之前的代码,这种情况下,从JDK1.8之后出现了Comparator接口,是对这种情况的一个弥补。

这种情况下,我们需要单独定义一个对象比较器,继承Comparator接口,并实现compare()方法。示例代码如下:

[java] view plain copy

class Student {  

    private String name;  

    private double score;  

    public Student(String name,double score){  

        this.name = name;  

        this.score = score;  

    }  

    public double getScore(){  

        return this.score;  

    }  

    @Override  

    public String toString() {  

        return "姓名:"+this.name+",分数:"+this.score;  

    }    

}  

class StudentComparator implements Comparator<Student> {  

    @Override  

    public int compare(Student o1,Student o2) {  

        if(o1.getScore() > o2.getScore()){  

            return 1;  

        }else if(o1.getScore() < o2.getScore()){  

            return -1;  

        }else{  

            return 0;  

        }  

    }  

}  

public class TestComparator {  

    public static void main(String[] args) {  

        Student[] sts = new Student[]{  

                new Student("小戴",60),  

                new Student("小王",90),  

                new Student("老王",80),  

                new Student("小萱",95)  

        };    

        java.util.Arrays.sort(sts, new StudentComparator());  

        System.out.println(java.util.Arrays.toString(sts));  

    }  

}  

Java中存在比较运算符:> < >=<=!===instanceof

只能比较基本数据类型,如果对于对象无法进行比较,如果在对象中需要实现对象之间的比较,只能通过ComparableCompartor接口实现

1Comparable接口(自然排序)

String、包装类都已经默认实现了mt4下载教程Comparable接口,并重写了int compareToT o)方法(定义排序规则),所以String、包装类都是可以进行排序的

默认是按照升序进行排序的

int compareTo(T o)

如果返回值是正数,代表调用者(this)的值比o的值要大

如果返回值是负数,代表调用者(this)的值比o的值要小

如果返回值是0,代表调用者(this)的值比o的值相等

如果一个自定义类需要实现排序功能,需要让当前类实现Comparable接口,重写int compareTo(T o)方法,在该方法中重写排序的规则

如果一个类一旦实现了Comparable接口,那么这个类的对象在任意地方都可以进行排序或者比较

/*

String、包装类都已经默认实现了Comparable接口,并重写了int compareToT o)方法

*/

public class CompareDemo {

public static void main(String[] args) {

int[] arr = {5,4,2,1,3};

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

 

String[] s = {"AA","CC","ZZ","BB","JJ"};

Arrays.sort(s);

System.out.println(Arrays.toString(s));

}

}

/*

对象之间比较

*/

public class CompareDemo {

public static void main(String[] args) {

Employee[] e = new Employee[5];

e[0] = new Employee("e001","Jack","d001");

e[1] = new Employee("e005","Tom","d010");

e[2] = new Employee("e010","Jack","d011");

e[3] = new Employee("e004","Rose","d005");

e[4] = new Employee("e009","Marry","d008");

Arrays.sort(e);

System.out.println(Arrays.toString(e));

}

}

class Employee implements Comparable<Employee>{

private String eno;

private String ename;

private String dept;

public String getEno() {

return eno;

}

public void setEno(String eno) {

this.eno = eno;

}

public String getEname() {

return ename;

}

public void setEname(String ename) {

this.ename = ename;

}

public String getDept() {

return dept;

}

public void setDept(String dept) {

this.dept = dept;

}

public Employee(String eno, String ename, String dept) {

super();

this.eno = eno;

this.ename = ename;

this.dept = dept;

}

public Employee() {

super();

}

@Override

public String toString() {

return "Employee [eno=" + eno + ", ename=" + ename + ", dept=" + dept + "]";

}

@Override

public int compareTo(Employee o) {

//借助StringcompareTo方法

return this.eno.compareTo(o.eno);

}

}

2Comparator接口(定制排序)

如果一个类没有实现Comparable接口,但是这个类又不方便实现Comparable接口(开闭原则),或者一个类已经实现了Comparable接口,但是其中的compareTo不满足我们的需求,那么我们可以使用Comparator接口方式进行定制排序

默认升序

int compare(T o1,T o2)

o1>o2 返回正数

o1<o2 返回负数

o1==o2 返回0

public class CompareDemo {

public static void main(String[] args) {

Employee[] e = new Employee[5];

e[0] = new Employee("e001","Jack","d001");

e[1] = new Employee("e003","Tom","d010");

e[2] = new Employee("e003","Jack","d011");

e[3] = new Employee("e004","Rose","d005");

e[4] = new Employee("e002","Marry","d008");

Arrays.sort(e, new Comparator<Employee>() {

@Override

public int compare(Employee o1, Employee o2) {

if(o1.getEno().compareTo(o2.getEno())!=0) {

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

}else {

return -o1.getEname().compareTo(o2.getEname());

}

}

});

System.out.println(Arrays.toString(e));

}

}

class Employee {

private String eno;

private String ename;

private String dept;

public String getEno() {

return eno;

}

public void setEno(String eno) {

this.eno = eno;

}

public String getEname() {

return ename;

}

public void setEname(String ename) {

this.ename = ename;

}

public String getDept() {

return dept;

}

public void setDept(String dept) {

this.dept = dept;

}

public Employee(String eno, String ename, String dept) {

super();

this.eno = eno;

this.ename = ename;

this.dept = dept;

}

public Employee() {

super();

}

@Override

public String toString() {

return "Employee [eno=" + eno + ", ename=" + ename + ", dept=" + dept + "]";

}

}

以上是关于java常用类——比较器的主要内容,如果未能解决你的问题,请参考以下文章

Java 常用类库 之 比较接口 Comparator

java常用类

031113_第11章:Java常用类库_比较器(ComparableComparator)

6-常用类

java常用类详细介绍及总结:字符串相关类日期时间API比较器接口SystemMathBigInteger与BigDecimal

Java常用工具类