如何使用Java8 lambda对流进行反向排序?

我使用java lambda对列表进行排序。

我怎么能逆向排序呢?

我看到这个帖子，但我想使用java 8 lambda。

这是我的代码(我使用* -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());
429022 次浏览
小开
最佳答案

你可以调整你在如何对ArrayList<Long>在Java中按递减顺序排列?中链接的解决方案，通过将它包装在lambda中:

.sorted((f1, f2) -> Long.compare(f2.lastModified(), f1.lastModified())

注意，f2是Long.compare的第一个参数，而不是第二个参数，因此结果将相反。

小开

使用

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

然后

.forEach(item -> item.delete());
小开

你可以使用一个方法引用:

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())
小开

这可以很容易地使用Java 8和反向比较器来实现。

我已经从一个目录中创建了一个文件列表，我使用一个简单的Comparator进行排序，然后调用reversed()来获得该Comparator的反向版本，以显示未排序、排序和反向排序。

参见下面的代码:

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());
}
}
}
小开

可供选择的共享方式:

ASC

List<Animal> 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).reversed()).collect(Collectors.toList());
小开

用java 8集合排序文件列表

示例如何使用Collections和Comparator Java 8对文件列表进行排序。

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 8按照下面的逆转顺序进行排序

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


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

对于反向排序，只需改变x1, x2的顺序来调用x1. compareto (x2)方法，结果将彼此反向

默认的顺序

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

相反的顺序

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

｝

List<Visit> visits = getResults();//Method making the list
Collections.sort(visits, Collections.reverseOrder());//Reverser order
小开

你可以像这样用自己的逻辑定义比较器;

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());
};

并在foreach中使用它:

list.stream()
.sorted(sortCredentialsByLastLogin.reversed())
.collect(Collectors.toList());
小开

这个简单的步骤应该可以使用Lambda .sorted (Comparator.reverseOrder ())实现反向排序，而不是所有这些复杂的操作

Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(Comparator.reverseOrder()).skip(numOfNewestToLeave)
.forEach(item -> item.delete());
小开 
    //sort Stream in reverse oreder with using Lambda Expressrion.


List<String> list = Arrays.asList("Ram","Rahul","Ravi","Vishal","Vaibhav","Rohit","Harit","Raghav","Shubhan");
List<String> sortedListLambda = list.stream().sorted((x,y)->y.compareTo(x)).collect(Collectors.toList());
System.out.println(sortedListLambda);

提交答案