优化算法优化设计答案大全英语

今天分享 Java 8 进行排序的 10 个姿势，其实就是把 Java 8 中的 Lambda、Stream、方法引用等知识点串起来

传统排序

现在有一个 List 集合：

public static List<User> LIST = new ArrayList() {{add(new User("Lisa", 23));add(new User("Tom", 11));add(new User("John", 16));add(new User("Jessie", 26));add(new User("Tony", 26));add(new User("Messy", 26));add(new User("Bob", 19));add(new User("Yoga", 65));}
};

jdk8 之前的排序：

/*** jdk8 之前的排序*/
private static void sortPreJdk8() {System.out.println("=====jdk8 之前的排序=====");List<User> list = new ArrayList<>(LIST);Collections.sort(list, new Comparator<User>() {@Overridepublic int compare(User u1, User u2) {return u1.getAge().compareTo(u2.getAge());}});for (User user : list) {System.out.println(user);}System.out.println();
}

Java 8 中的排序

1、Lambda 排序（带参数类型） Java 8 中的 List 接口新增了一个 sort 默认方法：

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

然后我们就可以把 Comparator 接口参数改成了用 Lambda 表达式的形式，用 Lambda 表达式干掉了匿名内部类，让代码更简洁。

使用示例如下：

/*** jdk8 lambda 排序，带参数类型*/
private static void sortWithJdk8Lambda1() {System.out.println("=====jdk8 lambda 排序，带参数类型=====");List<User> list = new ArrayList<>(LIST);list.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));list.forEach(System.out::println);System.out.println();
}

2、Lambda 排序（不带参数类型）
Lambda 表达式是可以不用带参数类型的，如下示例：

/*** jdk8 lambda 排序，不带参数类型*/
private static void sortWithJdk8Lambda2() {System.out.println("=====jdk8 lambda 排序，不带参数类型=====");List<User> list = new ArrayList<>(LIST);list.sort((u1, u2) -> u1.getAge().compareTo(u2.getAge()));list.forEach(System.out::println);System.out.println();
}

代码中的 u1, u2 并没有用 User 类修饰，它会自动推断为 User 类型，因为集合本身就是一个 User 泛型。

3、静态方法引用排序
除了 Lambda 表达式，还可以用类的静态方法引用：

/*** jdk8 静态方法引用排序*/
private static void sortWithJdk8StaticMethodRef() {System.out.println("=====jdk8 静态方法引用排序=====");List<User> list = new ArrayList<>(LIST);list.sort(User::compareAge);list.forEach(System.out::println);System.out.println();
}

使用方法引用之后代码是不是更简洁了？

4、实例方法引用排序
不仅可以用类的静态方法，还可以用类的实例普通方法引用：

/*** jdk8 实例方法引用排序*/
private static void sortWithJdk8InstanceMethodRef() {System.out.println("=====jdk8 实例方法引用排序=====");List<User> list = new ArrayList<>(LIST);list.sort(User.getInstance()::compare);list.forEach(System.out::println);System.out.println();
}

这个 getInstance 在这里实际上是一个单例，但和单例无关，任何类的实例都可以。

另外，这些知识点我也整理到了小程序，都是面试常考的，大家可以在Java面试库小程序在线刷题。

5、Comparator 工具类排序（升序）
Java 8 在 Comparator 接口中新增了 comparing 方法：

这个工具方法需要提供一个函数式接口参数，也就是要比较的哪个字段，最后还是返回 Comparator 接口实例。

使用示例如下：

/*** jdk8 升序排序，Comparator 提供的静态方法*/
private static void sortWithJdk8ComparatorAsc() {System.out.println("=====jdk8 升序排序=====");List<User> list = new ArrayList<>(LIST);list.sort(Comparator.comparing(User::getAge));//  list.sort(Comparator.comparing((user) -> user.getAge()));list.forEach(System.out::println);System.out.println();
}

既然是函数式接口，所以又可以用 Lambda、方法引用形式作为参数传入。

6、Comparator 工具类排序（降序）
还可以使用 Comparator.reversed/ reversedOrder 方法进行降序：

/*** jdk8 Comparator 工具类排序（降序）*/
private static void sortWithJdk8ComparatorDesc() {System.out.println("=====jdk8 降序降序=====");List<User> list = new ArrayList<>(LIST);list.sort(Comparator.comparing(User::getAge).reversed());list.forEach(System.out::println);System.out.println();
}

7、组合排序
如果要先按用户的年龄排序，年龄相同的再按姓名排序，可以使用 Comparator 接口中的 thenComparing 默认方法：

private static void sortGroupWithJdk8() {System.out.println("=====jdk8 组合排序=====");List<User> list = new ArrayList<>(LIST);list.sort(Comparator.comparing(User::getAge).thenComparing(User::getName));list.forEach(System.out::println);System.out.println();
}

输出结果：

注意年龄 26 岁的人又按姓名按自然顺序排序了。

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

sorted 方法也是接收 Comparator 接口参数，所以我们也可以使用 Lambda、方法引用、Comparator 接口自身提供的工具方法对其调用：

/*** jdk8 Stream 排序*/
private static void sortWithJdk8Stream() {System.out.println("=====jdk8 Stream 排序=====");List<User> list = new ArrayList<>(LIST);list = list.stream().sorted(User::compareAge).collect(Collectors.toList());//  list = list.stream().sorted((u1, u2) -> u1.getAge().compareTo(u2.getAge())).collect(Collectors.toList());//  list = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());list.forEach(System.out::println);System.out.println();
}

所以使用 Stream 也可以扩展多种排序方法，见注释部分，这里就不展开了。另外，Stream 系列我之前写过一个专题了，这里不再展开，不懂的关注公众号Java技术栈，然后在公众号 Java 教程菜单中阅读。

9、并行 Stream 排序
有 Stream 排序，那就并行 Stream（parallelStream）排序：

/*** jdk8 并行 Stream 排序*/
private static void sortWithJdk8parallelStream() {System.out.println("=====jdk8 Stream 排序=====");List<User> list = new ArrayList<>(LIST);list = list.parallelStream().sorted(User::compareAge).collect(Collectors.toList());list.forEach(System.out::println);System.out.println();
}

10、Collections 排序
既然在 Java 8 中，Comparator 接口被定义成了函数式接口，那么我们传统的 Collections 工具类就可以改变了，我们也可以使用 Lambda、方法引用、Comparator 接口自身提供的工具方法对其调用：

/*** jdk8 Collections 排序*/
private static void sortWithCollections() {System.out.println("=====jdk8 Collections 排序=====");List<User> list = new ArrayList<>(LIST);Collections.sort(list, User::compareAge);//  Collections.sort(list, (u1, u2) -> u1.getAge().compareTo(u2.getAge()));
//  Collections.sort(list, Comparator.comparing(User::getAge));    list.forEach(System.out::println);System.out.println();
}

总结

本文列举了 Java 8 中的 10 种排序方法，其实就是 10 个案例，还可以扩展更多，只是给大家个参考，总体来说，其实可以分为 3 大类：

List 接口中的 sort 方法

Stream 接口中的 sorted 方法

Collections.sort 工具类方法

这三个方法都可以接收 Comparator 接口作为参数，并且 Comparator 接口在 Java 8 中被定义成了函数式接口，所以我们可以用 Lambda 表达式、方法引用、Comparator 自身工具类等不同的参数形式传入，可谓是太秀了。

这些方法性能如何呢？

写了一个小例子，1 万数据的集合，使用静态方法引用进行测试：

long start = System.currentTimeMillis();
List<User> list1 = new ArrayList<>(list);
list1.sort(User::compareAge);
System.out.println("List.sort: " + (System.currentTimeMillis() - start));start = System.currentTimeMillis();
List<User> list2 = new ArrayList<>(list);
Collections.sort(list2, User::compareAge);
System.out.println("Collections.sort: " + (System.currentTimeMillis() - start));start = System.currentTimeMillis();
List<User> list3 = new ArrayList<>(list);
list3.stream().sorted(User::compareAge).collect(Collectors.toList());
System.out.println("Stream.sorted: " + (System.currentTimeMillis() - start));

输出结果：

List.sort: 18 Collections.sort: 18 Stream.sorted: 48
tream 要略慢，因为多了两道转换的工序，但如果不是特别大的数据量，比如 1000 条数据的集合，这 3 个几乎性能一样，基本都在 1 毫秒内完成排序，对于普通小数据的排序可以闭着眼睛用了。