使用 Lambda 實現超強的排序功能

語言: CN / TW / HK

你好,我是看山。

我們在系統開發過程中,對數據排序是很常見的場景。一般來説,我們可以採用兩種方式:

  1. 藉助存儲系統(SQL、NoSQL、NewSQL 都支持)的排序功能,查詢的結果即是排好序的結果。
  2. 查詢結果為無序數據,在內存中排序。

今天要説的是第二種排序方式,在內存中實現數據排序。

首先,我們定義一個基礎類,後面我們將根據這個基礎類演示如何在內存中排序。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private String name;
    private int age;
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

基於Comparator排序

在 Java8 之前,我們都是通過實現Comparator接口完成排序,比如:

new Comparator<Student>() {
    @Override
    public int compare(Student h1, Student h2) {
        return h1.getName().compareTo(h2.getName());
    }
};

這裏展示的是匿名內部類的定義,如果是通用的對比邏輯,可以直接定義一個實現類。使用起來也比較簡單,如下就是應用:

@Test
void baseSortedOrigin() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    Collections.sort(students, new Comparator<Student>() {
        @Override
        public int compare(Student h1, Student h2) {
            return h1.getName().compareTo(h2.getName());
        }
    });
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

這裏使用了 Junit5 實現單元測試,用來驗證邏輯非常適合。

因為定義的Comparator是使用name字段排序,在 Java 中,String類型的排序是通過單字符的 ASCII 碼順序判斷的,J排在T的前面,所以Jerry排在第一個。

使用 Lambda 表達式替換Comparator匿名內部類

使用過 Java8 的 Lamdba 的應該知道,匿名內部類可以簡化為 Lambda 表達式為:

Collections.sort(students, (Student h1, Student h2) -> h1.getName().compareTo(h2.getName()));

在 Java8 中,List類中增加了sort方法,所以Collections.sort可以直接替換為:

students.sort((Student h1, Student h2) -> h1.getName().compareTo(h2.getName()));

根據 Java8 中 Lambda 的類型推斷,我們可以將指定的Student類型簡寫:

students.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));

至此,我們整段排序邏輯可以簡化為:

@Test
void baseSortedLambdaWithInferring() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    students.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

通過靜態方法抽取公共的 Lambda 表達式

我們可以在Student中定義一個靜態方法:

public static int compareByNameThenAge(Student s1, Student s2) {
    if (s1.name.equals(s2.name)) {
        return Integer.compare(s1.age, s2.age);
    } else {
        return s1.name.compareTo(s2.name);
    }
}

這個方法需要返回一個int類型參數,在 Java8 中,我們可以在 Lambda 中使用該方法:

@Test
void sortedUsingStaticMethod() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    students.sort(Student::compareByNameThenAge);
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

藉助Comparator的comparing方法

在 Java8 中,Comparator類新增了comparing方法,可以將傳遞的Function參數作為比較元素,比如:

@Test
void sortedUsingComparator() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    students.sort(Comparator.comparing(Student::getName));
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

多條件排序

我們在靜態方法一節中展示了多條件排序,還可以在Comparator匿名內部類中實現多條件邏輯:

@Test
void sortedMultiCondition() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12),
            new Student("Jerry", 13)
    );
    students.sort((s1, s2) -> {
        if (s1.getName().equals(s2.getName())) {
            return Integer.compare(s1.getAge(), s2.getAge());
        } else {
            return s1.getName().compareTo(s2.getName());
        }
    });
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

從邏輯來看,多條件排序就是先判斷第一級條件,如果相等,再判斷第二級條件,依次類推。在 Java8 中可以使用comparing和一系列thenComparing表示多級條件判斷,上面的邏輯可以簡化為:

@Test
void sortedMultiConditionUsingComparator() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12),
            new Student("Jerry", 13)
    );
    students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge));
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

這裏的thenComparing方法是可以有多個的,用於表示多級條件判斷,這也是函數式編程的方便之處。

在Stream中進行排序

Java8 中,不但引入了 Lambda 表達式,還引入了一個全新的流式 API:Stream API,其中也有sorted方法用於流式計算時排序元素,可以傳入Comparator實現排序邏輯:

@Test
void streamSorted() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final Comparator<Student> comparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
    final List<Student> sortedStudents = students.stream()
            .sorted(comparator)
            .collect(Collectors.toList());
    Assertions.assertEquals(sortedStudents.get(0), new Student("Jerry", 12));
}

同樣的,我們可以通過 Lambda 簡化書寫:

@Test
void streamSortedUsingComparator() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final Comparator<Student> comparator = Comparator.comparing(Student::getName);
    final List<Student> sortedStudents = students.stream()
            .sorted(comparator)
            .collect(Collectors.toList());
    Assertions.assertEquals(sortedStudents.get(0), new Student("Jerry", 12));
}

倒序排列

調轉排序判斷

排序就是根據compareTo方法返回的值判斷順序,如果想要倒序排列,只要將返回值取返即可:

@Test
void sortedReverseUsingComparator2() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final Comparator<Student> comparator = (h1, h2) -> h2.getName().compareTo(h1.getName());
    students.sort(comparator);
    Assertions.assertEquals(students.get(0), new Student("Tom", 10));
}

可以看到,正序排列的時候,我們是h1.getName().compareTo(h2.getName())​,這裏我們直接倒轉過來,使用的是h2.getName().compareTo(h1.getName())​,也就達到了取反的效果。在 Java 的Collections​中定義了一個java.util.Collections.ReverseComparator內部私有類,就是通過這種方式實現元素反轉。

藉助Comparator​的reversed方法倒序

在 Java8 中新增了reversed方法實現倒序排列,用起來也是很簡單:

@Test
void sortedReverseUsingComparator() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final Comparator<Student> comparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
    students.sort(comparator.reversed());
    Assertions.assertEquals(students.get(0), new Student("Tom", 10));
}

在Comparator.comparing中定義排序反轉

comparing方法還有一個重載方法,java.util.Comparator#comparing(java.util.function.Function<? super T,? extends U>, java.util.Comparator<? super U>),第二個參數就可以傳入Comparator.reverseOrder(),可以實現倒序:

@Test
void sortedUsingComparatorReverse() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    students.sort(Comparator.comparing(Student::getName, Comparator.reverseOrder()));
    Assertions.assertEquals(students.get(0), new Student("Jerry", 12));
}

在Stream中定義排序反轉

在Stream中的操作與直接列表排序類似,可以反轉Comparator定義,也可以使用Comparator.reverseOrder()反轉。實現如下:

@Test
void streamReverseSorted() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final Comparator<Student> comparator = (h1, h2) -> h2.getName().compareTo(h1.getName());
    final List<Student> sortedStudents = students.stream()
            .sorted(comparator)
            .collect(Collectors.toList());
    Assertions.assertEquals(sortedStudents.get(0), new Student("Tom", 10));
}
@Test
void streamReverseSortedUsingComparator() {
    final List<Student> students = Lists.newArrayList(
            new Student("Tom", 10),
            new Student("Jerry", 12)
    );
    final List<Student> sortedStudents = students.stream()
            .sorted(Comparator.comparing(Student::getName, Comparator.reverseOrder()))
            .collect(Collectors.toList());
    Assertions.assertEquals(sortedStudents.get(0), new Student("Tom", 10));
}

null 值的判斷

前面的例子中都是有值元素排序,能夠覆蓋大部分場景,但有時候我們還是會碰到元素中存在null的情況:

  1. 列表中的元素是 null。
  2. 列表中的元素參與排序條件的字段是 null。

如果還是使用前面的那些實現,我們會碰到NullPointException異常,即 NPE,簡單演示一下:

@Test
void sortedNullGotNPE() {
    final List<Student> students = Lists.newArrayList(
            null,
            new Student("Snoopy", 12),
            null
    );
    Assertions.assertThrows(NullPointerException.class,
            () -> students.sort(Comparator.comparing(Student::getName)));
}

所以,我們需要考慮這些場景。

元素是 null 的笨拙實現

最先想到的就是判空:

@Test
void sortedNullNoNPE() {
    final List<Student> students = Lists.newArrayList(
            null,
            new Student("Snoopy", 12),
            null
    );
    students.sort((s1, s2) -> {
        if (s1 == null) {
            return s2 == null ? 0 : 1;
        } else if (s2 == null) {
            return -1;
        }
        return s1.getName().compareTo(s2.getName());
    });

    Assertions.assertNotNull(students.get(0));
    Assertions.assertNull(students.get(1));
    Assertions.assertNull(students.get(2));
}

我們可以將判空的邏輯抽取出一個Comparator,通過組合方式實現:

class NullComparator<T> implements Comparator<T> {
    private final Comparator<T> real;

    NullComparator(Comparator<? super T> real) {
        this.real = (Comparator<T>) real;
    }
    @Override
    public int compare(T a, T b) {
        if (a == null) {
            return (b == null) ? 0 : 1;
        } else if (b == null) {
            return -1;
        } else {
            return (real == null) ? 0 : real.compare(a, b);
        }
    }
}

在 Java8 中已經為我們準備了這個實現。

使用Comparator.nullsLast和Comparator.nullsFirst

使用Comparator.nullsLast實現null在結尾:

@Test
void sortedNullLast() {
    final List<Student> students = Lists.newArrayList(
            null,
            new Student("Snoopy", 12),
            null
    );
    students.sort(Comparator.nullsLast(Comparator.comparing(Student::getName)));
    Assertions.assertNotNull(students.get(0));
    Assertions.assertNull(students.get(1));
    Assertions.assertNull(students.get(2));
}

使用Comparator.nullsFirst實現null在開頭:

@Test
void sortedNullFirst() {
    final List<Student> students = Lists.newArrayList(
            null,
            new Student("Snoopy", 12),
            null
    );
    students.sort(Comparator.nullsFirst(Comparator.comparing(Student::getName)));
    Assertions.assertNull(students.get(0));
    Assertions.assertNull(students.get(1));
    Assertions.assertNotNull(students.get(2));
}

是不是很簡單,接下來我們看下如何實現排序條件的字段是 null 的邏輯。

排序條件的字段是 null

這個就是藉助Comparator的組合了,就像是套娃實現了,需要使用兩次Comparator.nullsLast,這裏列出實現:

@Test
void sortedNullFieldLast() {
    final List<Student> students = Lists.newArrayList(
            new Student(null, 10),
            new Student("Snoopy", 12),
            null
    );
    final Comparator<Student> nullsLast = Comparator.nullsLast(
            Comparator.nullsLast( // 1
                    Comparator.comparing(
                            Student::getName,
                            Comparator.nullsLast( // 2
                                    Comparator.naturalOrder() // 3
                            )
                    )
            )
    );
    students.sort(nullsLast);
    Assertions.assertEquals(students.get(0), new Student("Snoopy", 12));
    Assertions.assertEquals(students.get(1), new Student(null, 10));
    Assertions.assertNull(students.get(2));
}

代碼邏輯如下:

  1. 代碼 1 是第一層 null-safe 邏輯,用於判斷元素是否為 null。
  2. 代碼 2 是第二層 null-safe 邏輯,用於判斷元素的條件字段是否為 null。
  3. 代碼 3 是條件Comparator,這裏使用了Comparator.naturalOrder(),是因為使用了String排序,也可以寫為String::compareTo。如果是複雜判斷,可以定義一個更加複雜的Comparator,組合模式就是這麼好用,一層不夠再套一層。

總結

本文演示了使用 Java8 中使用 Lambda 表達式實現各種排序邏輯,新增的語法糖真香。

本文轉載自微信公眾號「看山的小屋」,可以通過以下二維碼關注。轉載本文請聯繫看山的小屋公眾號。