Java 8比较器：如何对列表进行排序

在本文中，我们将看到几个有关如何在Java 8中对列表进行排序的示例。

按字母顺序对字符串列表进行排序

List<String> cities = Arrays.asList(
       "Milan",
       "london",
       "San Francisco",
       "Tokyo",
       "New Delhi"
);
System.out.println(cities);
//[Milan, london, San Francisco, Tokyo, New Delhi]

cities.sort(String.CASE_INSENSITIVE_ORDER);
System.out.println(cities);
//[london, Milan, New Delhi, San Francisco, Tokyo]

cities.sort(Comparator.naturalOrder());
System.out.println(cities);
//[Milan, New Delhi, San Francisco, Tokyo, london]

我们用小写的“ L”书写了伦敦，以更好地突出Comparator.naturalOrder（）（它返回一个以大写字母优先排序的比较器）和 String.CASE_INSENSITIVE_ORDER（一个不区分大小写的比较器）之间的区别。

基本上，在Java 7中，我们使用的是接受列表的Collections.sort（），最后是一个Comparator；在Java 8中，我们有一个新的 List.sort（），它接受Comparator。

对整数列表进行排序

List<Integer> numbers = Arrays.asList(6, 2, 1, 4, 9);
System.out.println(numbers); //[6, 2, 1, 4, 9]

numbers.sort(Comparator.naturalOrder());
System.out.println(numbers); //[1, 2, 4, 6, 9]

按字符串字段对列表排序

假设我们有Movie类，并且想按标题对List进行排序。在本例中，我们可以使用Comparator.comparing（）并传递一个函数，该函数提取用于排序的字段-标题。

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings"),
        new Movie("Back to the future"),
        new Movie("Carlito's way"),
        new Movie("Pulp fiction"));

movies.sort(Comparator.comparing(Movie::getTitle));

movies.forEach(System.out::println);

输出将是：

Movie{title='Back to the future'}
Movie{title='Carlito's way'}
Movie{title='Lord of the rings'}
Movie{title='Pulp fiction'}

您可能已经注意到，我们没有通过比较器，但是列表已正确排序。这是因为title（提取的字段）是一个String，并且String实现了Comparable接口。如果您查看Comparator.comparing（）实现，将会看到它调用 compareTo 提取的键。

return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));

按双字段对列表排序

以类似的方式，我们可以使用Comparator.comparingDouble（）来比较double值。在示例中，我们要按等级从最高到最低排序电影列表。

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8),
        new Movie("Back to the future", 8.5),
        new Movie("Carlito's way", 7.9),
        new Movie("Pulp fiction", 8.9));

movies.sort(Comparator.comparingDouble(Movie::getRating)
                      .reversed());

movies.forEach(System.out::println);

为了比较默认的自然顺序，我们在Comparator上使用了 reverse函数。即从最低到最高。Comparator.comparingDouble（）在后台使用Double.compare（）。

如果需要比较int或long，则可以分别使用compareInt（）和compareingLong（）。

使用自定义比较器对列表进行排序

在前面的示例中，由于没有必要指定任何比较器，因此我们没有指定，但是让我们来看一个定义自定义比较器的示例。我们的Movie类具有一个新字段-“ stard”，该字段使用第三个构造函数参数设置。在示例中，我们希望对列表进行排序，以便在列表顶部为已加星标的电影加注星标。

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito's way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));

movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie m1, Movie m2) {
        if(m1.getStarred() == m2.getStarred()){
            return 0;
        }
        return m1.getStarred() ? -1 : 1;
     }
});

movies.forEach(System.out::println);

电影。的forEach（系统。出来::的println）; 结果将是：

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Back to the future', rating=8.5}
Movie{starred=false, title='Pulp fiction', rating=8.9}

当然，我们可以使用lambda表达式代替Anonymous类，如下所示：

movies.sort((m1, m2) -> {
    if(m1.getStarred() == m2.getStarred()){
        return 0;
    }
    return m1.getStarred() ? -1 : 1;
});

我们也可以再次使用Comparator.comparing（）：

movies.sort(Comparator.comparing(Movie::getStarred, (star1, star2) -> {
    if(star1 == star2){
         return 0;
    }
    return star1 ? -1 : 1;
}));

在最后一个示例中，Comparator.comparing（）使用函数来提取用于排序的键作为第一个参数，并使用Comparator作为第二个参数。该比较器使用提取的键进行比较。star1和star2是布尔值，分别代表m1.getStarred（）和m2.getStarred（）。

使用比较器链对列表进行排序

在最后一个示例中，我们希望在顶部加注星标的电影，然后按评分排序。

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito's way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));

movies.sort(Comparator.comparing(Movie::getStarred)
                      .reversed()
                      .thenComparing(Comparator.comparing(Movie::getRating)
                      .reversed())
);

movies.forEach(System.out::println);

输出为：

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Pulp fiction', rating=8.9}
Movie{starred=false, title='Back to the future', rating=8.5}

如您所见，我们首先按星标排序，然后按评分-两者都颠倒了，因为我们要首先获得最高价值，然后才是真实。

原文链接：https://blog.csdn.net/Beibnjin/article/details/113827586?utm_medium=distribute.pc_category.none-task-blog-hot-1.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-1.nonecase&request_id=

Java 8比较器：如何对列表进行排序

热门标签