如何使用Java8 lambda按相反顺序对流进行排序？

我正在使用JavaLambda对列表进行排序

我怎样才能以相反的方式进行排序

我看到了这个，但是我想使用Java8Lambda

这是我的代码（我使用了*-1）作为黑客代码

Arrays.asList(files).stream()
    .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
    .sorted(new Comparator<File>() {
        public int compare(File o1, File o2) {
            int answer;
            if (o1.lastModified() == o2.lastModified()) {
                answer = 0;
            } else if (o1.lastModified() > o2.lastModified()) {
                answer = 1;
            } else {
                answer = -1;
            }
            return -1 * answer;
        }
    })
    .skip(numOfNewestToLeave)
    .forEach(item -> item.delete());

Arrays.asList（files.stream（））
.filter（文件->isNameLikeBaseLine（文件，baseLineFile.getName（））
.sorted（新的比较器（）{
公共整数比较（文件o1、文件o2）{
int答案；
如果（o1.lastModified（）==o2.lastModified（））{
答案=0；
}else if（o1.lastModified（）>o2.lastModified（））{
答案=1；
}否则{
答案=-1；
}
返回-1*答案；
}
})
.skip（numOfNewestToLeave）
.forEach（项目->项目.delete（））；

您可以通过将链接的解决方案包装在lambda中来调整它：

.sorted（（f1，f2）->Long.compare（f2.lastModified（），f1.lastModified（））

请注意，f2是

Long的第一个参数。请比较
，而不是第二个参数，因此结果将颠倒。
使用

Comparator<File> comparator = Comparator.comparing(File::lastModified); 
Collections.sort(list, comparator.reversed());

您可以使用方法引用：

import static java.util.Comparator.*;
import static java.util.stream.Collectors.*;

Arrays.asList(files).stream()
    .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
    .sorted(comparing(File::lastModified).reversed())
    .skip(numOfNewestToLeave)
    .forEach(item -> item.delete());

在方法引用的替代方案中，可以使用lambda表达式，因此比较的参数变为：

.sorted(comparing(file -> file.lastModified()).reversed());

如果您的流元素实现了
Comparable
，则解决方案会变得更简单：

 ...stream()
 .sorted(Comparator.reverseOrder())

这可以很容易地通过使用Java8和反向函数来实现

我已经从一个目录创建了一个文件列表，我使用一个简单的排序比较器显示未排序、排序和反向排序的文件，然后对其调用reversed（），以获得该比较器的反向版本

见下面的代码：

package test;

import java.io.File;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

public class SortTest {
    public static void main(String... args) {
        File directory = new File("C:/Media");
        File[] files = directory.listFiles();
        List<File> filesList = Arrays.asList(files);

        Comparator<File> comparator = Comparator.comparingLong(File::lastModified);
        Comparator<File> reverseComparator = comparator.reversed();

        List<File> forwardOrder = filesList.stream().sorted(comparator).collect(Collectors.toList());
        List<File> reverseOrder = filesList.stream().sorted(reverseComparator).collect(Collectors.toList());

        System.out.println("*** Unsorted ***");
        filesList.forEach(SortTest::processFile);

        System.out.println("*** Sort ***");
        forwardOrder.forEach(SortTest::processFile);

        System.out.println("*** Reverse Sort ***");
        reverseOrder.forEach(SortTest::processFile);
    }

    private static void processFile(File file) {
        try {
            if (file.isFile()) {
                System.out.println(file.getCanonicalPath() + " - " + new Date(file.lastModified()));
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

封装测试；
导入java.io.File；
导入java.util.array；
导入java.util.Comparator；
导入java.util.Date；
导入java.util.List；
导入java.util.stream.collector；
公共类分类测试{
公共静态void main（字符串…参数）{
文件目录=新文件（“C:/Media”）；
File[]files=目录.listFiles（）；
List filesList=Arrays.asList（文件）；
Comparator Comparator=Comparator.comparingLong（文件：：lastModified）；
Comparator reverseComparator=Comparator.reversed（）；
List forwardOrder=filesList.stream（）.sorted（comparator）.collect（Collectors.toList（））；
List reverseOrder=filesList.stream（）.sorted（reverseComparator.collect（Collectors.toList（））；
System.out.println（“***未排序***”）；
forEach（SortTest:：processFile）；
System.out.println（“***排序***”）；
forwardOrder.forEach（SortTest:：processFile）；
System.out.println（“***反向排序***”）；
forEach（SortTest:：processFile）；
}
私有静态void进程文件（文件文件）{
试一试{
if（file.isFile（））{
System.out.println（file.getCanonicalPath（）+“-”+新日期（file.lastModified（））；
}
}捕获（例外e）{
System.out.println（e.getMessage（））；
}
}
}
可供选择的共享方式：

ASC

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName)).collect(Collectors.toList());

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName).reversed()).collect(Collectors.toList());

List animals=this.service.findAll（）；
animals=animals.stream（）.sorted（Comparator.comparing（Animal:：getName））.collect（Collectors.toList（））；

DESC

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName)).collect(Collectors.toList());

List<Animal> animals = this.service.findAll();
animals = animals.stream().sorted(Comparator.comparing(Animal::getName).reversed()).collect(Collectors.toList());

List animals=this.service.findAll（）；
animals=animals.stream（）.sorted（Comparator.comparing（Animal:：getName）.reversed（））.collect（collector.toList（））；
使用java 8集合对文件列表进行排序

示例如何使用集合和比较器Java8对文件列表进行排序

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ShortFile {

    public static void main(String[] args) {
        List<File> fileList = new ArrayList<>();
        fileList.add(new File("infoSE-201904270100.txt"));
        fileList.add(new File("infoSE-201904280301.txt"));
        fileList.add(new File("infoSE-201904280101.txt"));
        fileList.add(new File("infoSE-201904270101.txt"));

        fileList.forEach(x -> System.out.println(x.getName()));
        Collections.sort(fileList, Comparator.comparing(File::getName).reversed());
        System.out.println("===========================================");
        fileList.forEach(x -> System.out.println(x.getName()));
    }
}

导入java.io.File；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公共类短文件{
公共静态void main（字符串[]args）{
List fileList=new ArrayList（）；
添加（新文件（“infoSE-201904270100.txt”）；
添加（新文件（“infoSE-201904280301.txt”）；
添加（新文件（“infoSE-201904280101.txt”）；
添加（新文件（“infoSE-201904270101.txt”）；
fileList.forEach（x->System.out.println（x.getName（））；
Collections.sort（fileList，Comparator.comparing（File:：getName.reversed（））；
System.out.println（“======================================================================”）；
fileList.forEach（x->System.out.println（x.getName（））；
}
}
简单地说，使用Comparator和Collection，您可以使用Java8以反转顺序进行如下排序

import java.util.Comparator;;
import java.util.stream.Collectors;

Arrays.asList(files).stream()
    .sorted(Comparator.comparing(File::getLastModified).reversed())
    .collect(Collectors.toList());

对于反向排序，只需更改调用x1.compareTo（x2）方法的x1，x2的顺序，结果将彼此相反

默认顺序

List<String> sortedByName = citiesName.stream().sorted((s1,s2)->s1.compareTo(s2)).collect(Collectors.toList());
System.out.println("Sorted by Name : "+ sortedByName);

List sortedByName=citiesName.stream（）.sorted（（s1，s2）->s1.compareTo（s2））.collect（Collectors.toList（））；
System.out.println（“按名称排序：+sortedByName”）；

相反顺序

List<String> reverseSortedByName = citiesName.stream().sorted((s1,s2)->s2.compareTo(s1)).collect(Collectors.toList());
System.out.println("Reverse Sorted by Name : "+ reverseSortedByName );

Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(Comparator.reverseOrder()).skip(numOfNewestToLeave)
.forEach(item -> item.delete());

List reverseSortedByName=citiesName.stream（）.sorted（（s1，s2）->s2.compareTo（s1））.collect（Collectors.toList（））；
System.out.println（“按名称反向排序：”+reverseSortedByName）；
如果要按对象的日期类型属性排序，则

public class Visit implements Serializable, Comparable<Visit>{
private static final long serialVersionUID = 4976278839883192037L;

private Date dos;

public Date getDos() {
    return dos;
}

public void setDos(Date dos) {
    this.dos = dos;
}

@Override
public int compareTo(Visit visit) {
    return this.getDos().compareTo(visit.getDos());
}

公共类访问实现了可序列化、可比较的{
私有静态最终长serialVersionUID=4976278839883192037L；
私人约会；
公共日期getDos（）{
返回dos；
}
公共作废设置（日期设置）{
this.dos=dos；
}
@凌驾
公共国际比较（参观）{
返回这个.getDos（）.compareTo（访问.getDos（））；
}

}

List visions=getResults（）；//创建列表的方法
Collections.sort（访问，Collections.reverseOrder（））；//反向顺序
您可以用自己的逻辑定义比较器，如下所示

private static final Comparator<UserResource> sortByLastLogin = (c1, c2) -> {
    if (Objects.isNull(c1.getLastLoggedin())) {
        return -1;
    } else if (Objects.isNull(c2.getLastLoggedin())) {
        return 1;
    }
    return c1.getLastLoggedin().compareTo(c2.getLastLoggedin());
};   

与所有这些复杂情况不同的是，这个简单的步骤应该可以使用Lambda.sorted（Comparator.reverseOrder（））

“反向顺序”是什么意思？如果将
-1*答案
替换为
答案
，则顺序将
Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(Comparator.reverseOrder()).skip(numOfNewestToLeave)
.forEach(item -> item.delete());