使用 Lambda 實現超強的排序功能
你好，我是看山。
我們在系統開發過程中，對資料排序是很常見的場景。一般來說，我們可以採用兩種方式：
- 藉助儲存系統（SQL、NoSQL、NewSQL 都支援）的排序功能，查詢的結果即是排好序的結果。
- 查詢結果為無序資料，在記憶體中排序。
今天要說的是第二種排序方式，在記憶體中實現資料排序。
首先，我們定義一個基礎類，後面我們將根據這個基礎類演示如何在記憶體中排序。
@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的情況：
- 列表中的元素是 null。
- 列表中的元素參與排序條件的欄位是 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 是第一層 null-safe 邏輯，用於判斷元素是否為 null。
- 程式碼 2 是第二層 null-safe 邏輯，用於判斷元素的條件欄位是否為 null。
- 程式碼 3 是條件Comparator，這裡使用了Comparator.naturalOrder()，是因為使用了String排序，也可以寫為String::compareTo。如果是複雜判斷，可以定義一個更加複雜的Comparator，組合模式就是這麼好用，一層不夠再套一層。
總結
本文演示了使用 Java8 中使用 Lambda 表示式實現各種排序邏輯，新增的語法糖真香。
本文轉載自微信公眾號「看山的小屋」，可以通過以下二維碼關注。轉載本文請聯絡看山的小屋公眾號。
「其他文章」
- Spring中實現非同步呼叫的方式有哪些？
- 帶引數的全型別 Python 裝飾器
- 整理了幾個Python正則表示式，拿走就能用！
- SOLID：開閉原則Go程式碼實戰
- React中如何引入CSS呢
- 一個新視角：前端框架們都卷錯方向了？
- 編碼中的Adapter，不僅是一種設計模式，更是一種架構理念與解決方案
- 手寫程式語言-遞迴函式是如何實現的？
- 一文搞懂模糊匹配：定義、過程與技術
- 新來個阿里 P7，僅花 2 小時，做出一個多執行緒永動任務，看完直接跪了
- Puzzlescript，一種開發H5益智遊戲的引擎
- @Autowired和@Resource到底什麼區別，你明白了嗎？
- CSS transition 小技巧！如何保留 hover 的狀態？
- React如此受歡迎離不開這4個主要原則
- LeCun再炮轟Marcus： 他是心理學家，不是搞AI的
- Java保證執行緒安全的方式有哪些？
- 19個殺手級 JavaScript 單行程式碼，讓你看起來像專業人士
- Python 的"self"引數是什麼？
- 別整一坨 CSS 程式碼了，試試這幾個實用函式
- 再有人問你什麼是MVCC，就把這篇文章發給他！