java比较器

目录

1 利用sort函数对数组和List类型排序

1.1 升序

 1.2 降序

1.3 讲解

2 lambda表达式

3 实现Comparable接口

3.1 利用sort进行排序

3.2 实现代码

4 实现Comparator接口

 5 利用lambda表达式

6 总结

---

1 利用sort函数对数组和List类型排序

1.1 升序

Arrays.sort(nums,(a,b)->a-b);

list.sort(Comparator.naturalOrder());

list.sort((Integer a,Integer b)->a.compareTo(b));

//方法应用，Integer::compareTo
//编译器生成一个Integer接口的实例调用compareTo方法
list.sort(Integer::compareTo);

 1.2 降序

 list.sort(Comparator.reverseOrder());

其他的降序改变升序的表达式就可以得到

1.3 讲解

 public int compareTo(Integer anotherInteger) {
            return compare(this.value, anotherInteger.value);
        }

Integer类内部的compareTo方法

public final class Integer extends Number implements Comparable<Integer>

Integer类继承了Comparable方法

 Integer内部的compare方法
        public static int compare(int x, int y) {
            return (x < y) ? -1 : ((x == y) ? 0 : 1);
        }

2 lambda表达式

        Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。

基本表达形式

 (String first,String second)->first.length()-second.length();
 //表达形式 (参数)，箭头(->)，以及一个表达式
 //如果代码要完成的计算无法放到一个表达式中，我们可以将代码放入{}中，并包含显式的return语句
 (String first,String second)->{
      if(first.length()<second.length()) return 1;
       else if(first.length()>second.length()) return -1
       else return 0;
 }
 //如果可以推导出参数类型也可以忽略其类型
 Comparator<String>comp=(first,second)->first.length()-second.length();

        方法引用符  双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

3 实现Comparable接口

3.1 利用sort进行排序

        如果要让一个类实现排序服务就必须让他实现compareTo方法，要向sort方法提供对象的比较方式

3.2 实现代码

import java.util.Arrays;
public class EmployeeSortTest {
    public static void main(String[] args) {
        Employee staff[]=new Employee[3];
        staff[0]=new Employee("Tom",1000);
        staff[1]=new Employee("Cat",500);
        staff[2]=new Employee("Harry",2000);
        Arrays.sort(staff);
        System.out.println(Arrays.asList(staff).toString());
    }
}
class Employee implements Comparable<Employee>{
    String name;
    double salary;

    public Employee(String name, double salary) {
        this.name=name;
        this.salary=salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

    @Override
    public int compareTo(Employee other) {
        return Double.compare(salary,other.salary);
    }
}

4 实现Comparator接口

Arrays.sort方法第二个版本，有一个函数和一个比较器作为参数。

import java.util.Arrays;
import java.util.Comparator;

public class EmployeeSortTest {
    public static void main(String[] args) {
        Employee staff[]=new Employee[3];
        staff[0]=new Employee("Tom",1000);
        staff[1]=new Employee("Cat",500);
        staff[2]=new Employee("Harry",2000);
        Arrays.sort(staff,new Employee());
        System.out.println(Arrays.asList(staff).toString());
    }
}
class Employee implements Comparator<Employee> {
    String name;
    double salary;
    public Employee(){}
    public Employee(String name, double salary) {
        this.name=name;
        this.salary=salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }
    //这个compare方法是在比较器对象上调用的，而不是参数调用的
    @Override
    public int compare(Employee o1, Employee o2) {
        if(o1.salary>o2.salary){
            return 1;
        }
        else if(o1.salary<o2.salary){
            return -1;
        }
        else
            return 0;
    }
}

 5 利用lambda表达式

public class EmployeeSortTest {
    public static void main(String[] args) {
        Employee staff[]=new Employee[3];
        staff[0]=new Employee("Tom",1000);
        staff[1]=new Employee("Cat",500);
        staff[2]=new Employee("Harry",2000);
        Arrays.sort(staff,((o1, o2) -> {
            if(o1.salary>o2.salary){
                return 1;
            }
            else if(o1.salary<o2.salary){
                return -1;
            }
            else
                return 0;
        }));
        System.out.println(Arrays.asList(staff).toString());
    }
}
class Employee  {
    String name;
    double salary;
    public Employee(){}
    public Employee(String name, double salary) {
        this.name=name;
        this.salary=salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

}

6 总结

• java.lang.Comparable：是在一个类定义的时候默认实现好的接口，里面存在有compareTo()方法
• java.util.Comparator：是挽救的比较接口，需要单独定义一个比较规则类，定义有compare()、equals()方