ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java 8 排序的 10 个姿势，太秀了吧！同事直呼看不懂。。 [打印本页]
作者: 泉缘泉    时间: 2022-6-23 21:13
标题: Java 8 排序的 10 个姿势，太秀了吧！同事直呼看不懂。。
大家好，我是栈长。
本公众号（Java技术栈）平时会发不少干货，值得大家的关注，都是栈长多年积累的经验精华，希望对大家有帮助，大家可以置顶下公众号，别错过任何精彩内容！
不废话了，不信你继续往下看，＝-=
今天栈长就分享 Java 8 进行排序的 10 个姿势，原来还有这么多排序技巧，其实就是把 Java 8 中的 Lambda、Stream、方法引用等知识点串起来，栈长的同事直呼还看不懂。。
传统排序

现在有一个 List 集合：
  1. public static List<User> LIST = new ArrayList() {
  2.     {
  3.         add(new User("Lisa", 23));
  4.         add(new User("Tom", 11));
  5.         add(new User("John", 16));
  6.         add(new User("Jessie", 26));
  7.         add(new User("Tony", 26));
  8.         add(new User("Messy", 26));
  9.         add(new User("Bob", 19));
  10.         add(new User("Yoga", 65));
  11.     }
  12. };
复制代码
jdk8 之前的排序：
  1. /**
  2. * jdk8 之前的排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortPreJdk8() {
  7.     System.out.println("=====jdk8 之前的排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     Collections.sort(list, new Comparator<User>() {
  11.         @Override
  12.         public int compare(User u1, User u2) {
  13.             return u1.getAge().compareTo(u2.getAge());
  14.         }
  15.     });
  17.     for (User user : list) {
  18.         System.out.println(user);
  19.     }
  20.     System.out.println();
  21. }
复制代码
在 Java 8 出来之前，排序基本上要这么写，可是 Java 8 都出来这么多年了，你还在这么排序那就太 Low 了！
Java 8 中的排序

对 Java 8 新增的知识点这篇不再详述，还不会用的可以关注公众号：Java技术栈，在后台回复：java，Java 8+ 系列教程我都写了一堆了。
本篇就直接上干货，看我怎么用 Java 8 排序！
1、Lambda 排序（带参数类型）

Java 8 中的 List 接口新增了一个 sort 默认方法：

接收 Comparator 接口参数，这个接口在 Java 8 中被修饰为函数式接口：

然后我们就可以把 Comparator 接口参数改成了用 Lambda 表达式的形式，用 Lambda 表达式干掉了匿名内部类，让代码更简洁。
使用示例如下：
  1. /**
  2. * jdk8 lambda 排序，带参数类型
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8Lambda1() {
  7.     System.out.println("=====jdk8 lambda 排序，带参数类型=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
2、Lambda 排序（不带参数类型）

Lambda 表达式是可以不用带参数类型的，如下示例：
  1. /**
  2. * jdk8 lambda 排序，不带参数类型
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8Lambda2() {
  7.     System.out.println("=====jdk8 lambda 排序，不带参数类型=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
代码中的 u1, u2 并没有用 User 类修饰，它会自动推断为 User 类型，因为集合本身就是一个 User 泛型。
3、静态方法引用排序

除了 Lambda 表达式，还可以用类的静态方法引用：
  1. /**
  2. * jdk8 静态方法引用排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8StaticMethodRef() {
  7.     System.out.println("=====jdk8 静态方法引用排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort(User::compareAge);
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
使用方法引用之后代码是不是更简洁了？
4、实例方法引用排序

不仅可以用类的静态方法，还可以用类的实例普通方法引用：
  1. /**
  2. * jdk8 实例方法引用排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8InstanceMethodRef() {
  7.     System.out.println("=====jdk8 实例方法引用排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort(User.getInstance()::compare);
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
这个 getInstance 在这里实际上是一个单例，但和单例无关，任何类的实例都可以。
另外，这些知识点我也整理到了小程序，都是面试常考的，大家可以在Java面试库小程序在线刷题。
5、Comparator 工具类排序（升序）

Java 8 在 Comparator 接口中新增了 comparing 方法：

这个工具方法需要提供一个函数式接口参数，也就是要比较的哪个字段，最后还是返回 Comparator 接口实例。
使用示例如下：
  1. /**
  2. * jdk8 升序排序，Comparator 提供的静态方法
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8ComparatorAsc() {
  7.     System.out.println("=====jdk8 升序排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort(Comparator.comparing(User::getAge));
  11.    
  12. //  list.sort(Comparator.comparing((user) -> user.getAge()));
  14.     list.forEach(System.out::println);
  15.     System.out.println();
  16. }
复制代码
既然是函数式接口，所以又可以用 Lambda、方法引用形式作为参数传入。
本文所有完整示例源代码已经上传：
https://github.com/javastacks/javastack
6、Comparator 工具类排序（降序）

还可以使用 Comparator.reversed/ reversedOrder 方法进行降序：
  1. /**
  2. * jdk8 Comparator 工具类排序（降序）
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8ComparatorDesc() {
  7.     System.out.println("=====jdk8 降序降序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list.sort(Comparator.comparing(User::getAge).reversed());
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
Comparator.reversed 和 reversedOrder 的区别在于，reversedOrder 适用于基本数据类型的集合的自然排序，而 reversed 是对 Comparator 自身的封装，适用于对象的自定义排序。
7、组合排序

如果要先按用户的年龄排序，年龄相同的再按姓名排序，可以使用 Comparator 接口中的 thenComparing 默认方法：
  1. private static void sortGroupWithJdk8() {
  2.     System.out.println("=====jdk8 组合排序=====");
  3.     List<User> list = new ArrayList<>(LIST);
  5.     list.sort(Comparator.comparing(User::getAge).thenComparing(User::getName));
  7.     list.forEach(System.out::println);
  8.     System.out.println();
  9. }
复制代码
输出结果：
  1. =====jdk8 组合排序=====
  2. 11: Tom
  3. 16: John
  4. 19: Bob
  5. 23: Lisa
  6. 26: Jessie
  7. 26: Messy
  8. 26: Tony
  9. 65: Yoga
复制代码
注意年龄 26 岁的人又按姓名按自然顺序排序了。
8、Stream 排序

还可以把 List 集合转换为 Stream，然后使用其 sorted 方法：

sorted 方法也是接收 Comparator 接口参数，所以我们也可以使用 Lambda、方法引用、Comparator 接口自身提供的工具方法对其调用：
  1. /**
  2. * jdk8 Stream 排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8Stream() {
  7.     System.out.println("=====jdk8 Stream 排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list = list.stream().sorted(User::compareAge).collect(Collectors.toList());
  12. //  list = list.stream().sorted((u1, u2) -> u1.getAge().compareTo(u2.getAge())).collect(Collectors.toList());
  14. //  list = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());
  15.    
  17.     list.forEach(System.out::println);
  18.     System.out.println();
  19. }
复制代码
所以使用 Stream 也可以扩展多种排序方法，见注释部分，这里就不展开了。另外，Stream 系列我之前写过一个专题了，这里不再展开，不懂的关注公众号Java技术栈，然后在公众号 Java 教程菜单中阅读。
9、并行 Stream 排序

有 Stream 排序，那就并行 Stream（parallelStream）排序：
  1. /**
  2. * jdk8 并行 Stream 排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithJdk8parallelStream() {
  7.     System.out.println("=====jdk8 Stream 排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     list = list.parallelStream().sorted(User::compareAge).collect(Collectors.toList());
  12.     list.forEach(System.out::println);
  13.     System.out.println();
  14. }
复制代码
10、Collections 排序

既然在 Java 8 中，Comparator 接口被定义成了函数式接口，那么我们传统的 Collections 工具类就可以改变了，我们也可以使用 Lambda、方法引用、Comparator 接口自身提供的工具方法对其调用：
  1. /**
  2. * jdk8 Collections 排序
  3. * @author: 栈长
  4. * @from: 公众号Java技术栈
  5. */
  6. private static void sortWithCollections() {
  7.     System.out.println("=====jdk8 Collections 排序=====");
  8.     List<User> list = new ArrayList<>(LIST);
  10.     Collections.sort(list, User::compareAge);
  11.    
  12. //  Collections.sort(list, (u1, u2) -> u1.getAge().compareTo(u2.getAge()));
  13. //  Collections.sort(list, Comparator.comparing(User::getAge));   
  15.     list.forEach(System.out::println);
  16.     System.out.println();
  17. }
复制代码
你学废了吗？
总结

本文栈长列举了 Java 8 中的 10 种排序方法，其实就是 10 个案例，还可以扩展更多，只是给大家个参考，总体来说，其实可以分为 3 大类：
这三个方法都可以接收 Comparator 接口作为参数，并且 Comparator 接口在 Java 8 中被定义成了函数式接口，所以我们可以用 Lambda 表达式、方法引用、Comparator 自身工具类等不同的参数形式传入，可谓是太秀了。
这些方法性能如何呢？
栈长写了一个小例子，1 万数据的集合，使用静态方法引用进行测试：
  1. long start = System.currentTimeMillis();
  2. List<User> list1 = new ArrayList<>(list);
  3. list1.sort(User::compareAge);
  4. System.out.println("List.sort: " + (System.currentTimeMillis() - start));
  6. start = System.currentTimeMillis();
  7. List<User> list2 = new ArrayList<>(list);
  8. Collections.sort(list2, User::compareAge);
  9. System.out.println("Collections.sort: " + (System.currentTimeMillis() - start));
  11. start = System.currentTimeMillis();
  12. List<User> list3 = new ArrayList<>(list);
  13. list3.stream().sorted(User::compareAge).collect(Collectors.toList());
  14. System.out.println("Stream.sorted: " + (System.currentTimeMillis() - start));
复制代码
输出结果：
List.sort: 18
Collections.sort: 18
Stream.sorted: 48
Stream 要略慢，因为多了两道转换的工序，但如果不是特别大的数据量，比如 1000 条数据的集合，这 3 个几乎性能一样，基本都在 1 毫秒内完成排序，对于普通小数据的排序可以闭着眼睛用了。
所以，你学废了吗？赶紧用在项目中吧，提升自己的硬实力，让同事对你刮目相看！再啰嗦一句，对 Java 8 新增的知识点还不会用的可以关注公众号：Java技术栈，在后台回复：java，Java 8+ 系列教程我都写了一堆了。
你还知道哪些排序技巧？欢迎留言分享～
本文所有完整示例源代码已经上传：
https://github.com/javastacks/javastack
欢迎 Star 学习，后面 Java 示例都会在这上面提供！
好了，今天的分享就到这里了，后面栈长会分享更多好玩的 Java 技术和最新的技术资讯，关注公众号Java技术栈第一时间推送，我也将主流 Java 面试题和参考答案都整理好了，在公众号后台回复关键字 "面试" 进行刷题。
最后，觉得我的文章对你用收获的话，动动小手，给个在看、转发，原创不易，栈长需要你的鼓励。
版权声明： 本文系公众号 "Java技术栈" 原创，转载、引用本文内容请注明出处，抄袭、洗稿一律投诉侵权，后果自负，并保留追究其法律责任的权利。
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4