Java8 Comparator接口和lambda表达式的使用

最近在刷题的时候，经常会遇到一些问题需要先对数据按照某种规则排序，再做下一步的处理。我们都知道如果相对某一个类的对象进行排序操作，只要这个类实现了Comparable<>接口，并且重写了CompareTo()方法即可直接通过对集合或数组调用sort()方法实现排序，例如

Student类实现Comparable接口

public class Student implements Comparable<Student> {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    //实现CompareTo方法，即可通过姓名字符的ASCII顺序进行排序
    @Override
    public int compareTo(@NotNull Student o) {
        return this.name.compareTo(o.name);
    }

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

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student(1, "zhangsan");
        Student s2 = new Student(2,"lisi");
        Student s3 = new Student(3, "Wangwu");

        List<Student> stu = new ArrayList<>();
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);

        Collections.sort(stu);
        System.out.println(stu);
    }
}

结果

[Student{id=3, name=’Wangwu’}, Student{id=2, name=’lisi’}, Student{id=1, name=’zhangsan’}]

但是，有的时候类本身没有实现“比较”这个功能，或者CompareTo()实现的并不是自己想比较的方法，那么我们就需要自己实现一个比较器。单独写一个类，实现Comparator接口，实现Compare()方法。然后将这个“定义如何比较某（两）个类”的对象传递到sort()方法中，使对象可以比较。比如我们想让刚才的Student使用name的长度进行排序：

一个定义比较方法的类，实现了Comparator接口

public class SortedById implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().length() - o2.getName().length();
    }
}

public class Test {
    public static void main(String[] args) {
        
        Student s1 = new Student(1, "zhangsan");
        Student s2 = new Student(2,"lisi");
        Student s3 = new Student(3, "Wangwu");

        List<Student> stu = new ArrayList<>();
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);

        Collections.sort(stu, new SortedById());
        System.out.println(stu);
    }
}

结果

[Student{id=2, name=’lisi’}, Student{id=3, name=’Wangwu’}, Student{id=1, name=’zhangsan’}]

实际上，这就是将一段代码直接传递到一个方法里面去，可是在Java中实现这样的操作并不容易。

当然，使用匿名内部类也可以实现不新增一个类就完成比较操作的定义：

Collections.sort(stu, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().length() - o2.getName().length();
            }
        });

lambda表达式的出现，使代码更加简洁，如下：

Collections.sort(stu, (o1, o2) -> o1.getName().length() - o2.getName().length());

sort()方法的第二个参数即是一段lambda表达式，它由()->{}的形式表示。

()中表示要传递的参数，由于sort()方法中，对要排序的内容已经有了说明，即第一个参数“stu”，所以编译器可以推导出第二个参数必然比较的是两个Student对象。如果无法推导，则需要指明类型：

Collections.sort(stu, (Student o1, Student o2) -> o1.getName().length() - o2.getName().length());

->之后指向一个方法体，如果不能用一句代码完成所需的计算，则需要加入{}

如果要提供的方法没有参数，则可以直接写为()->{………}

lambda表达式还为后续Java实现函数式编程提供了便利。当我们需要一个只包含一个抽象方法的接口的对象的时候，我们可以通过lambda表达式来实现。这种接口就成为函数式接口。

编程日常

comparator, Java, lambda