欢迎来到it培训的黄埔军校——智游教育!

java 8 比较器:如何对 list 排序-永利国际

于2017-04-11 10:14:12 发表在java知识库
在本文中,我们将看到几个关于如何在java 8中对list进行排序的例子。

按字母排序字符串列表

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]
london的“l”使用小写字母,是为了更好地突出 comparator.naturalorder() (返回首先排序大写字母的比较器)和 string.case_insensitive_order(返回不区分大小写的比较器)之间的差异。
基本上,在java 7中,我们使用collection.sort()接受list和最后的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类,并且我们要“按标题title”对list排序。我们可以使用 comparator.comparing() ,传递一个函数,函数提取用于排序title的字段——在本例中。
list 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'}
可能你会注意到我们没有通过任何comparator ,但正确排序了list。这是因为title——提取的字段——是一个字符串,并且字符串实现了可比较的接口。如果你看看comparator.comparing()实现,你会看到它对提取的键调用compareto。
return (comparator<t> & serializable)
            (c1, c2) -> keyextractor.apply(c1).compareto(keyextractor.apply(c2));

按double字段对列表排序

以类似的方式,我们可以使用 comparator.comparingdouble()来比较double值。在示例中,我们想按最高到最低的评分来订购movie列表。
list 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上使用reversed函数,以便反转默认的从最低到最高的自然顺序。 comparator.comparingdouble()在内部使用double.compare()。
如果你需要比较int或long,那么你可以分别使用comparingint()和comparinglong()。

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

在前面的例子中,我们没有指定任何比较器,因为没有必要,但让我们看一个例子,例子中我们定义了我们自己的比较器。我们的movie类有一个新的字段——“starred”——使用第三个构造函数参数设置。在示例中,我们要对列表进行排序,以便列表顶部为已加星标的电影。
list 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() {
    @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);
结果将是:
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作为第二个参数。comparator 使用提取的键进行比较,star1和star2真是布尔值,分别表示m1.getstarred()和m2.getstarred()。

用比较链排序列表

在最后一个例子中,我们要在顶部加上已加星标的电影,然后按评分排序。
list 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}
正如你所看到的,我们首先按星标,然后按评分进行排序——两者都反转,因为我们想要最高的值和真正的第一。