I'm using java lambda to sort a list.
how can I sort it in a reverse way?
I saw this post, but I want to use java 8 lambda.
Here is my code (I used * -1) as a hack
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());
This question is related to
java
lambda
java-8
java-stream
This can easily be done using Java 8 and the use of a reversed Comparator.
I have created a list of files from a directory, which I display unsorted, sorted and reverse sorted using a simple Comparator for the sort and then calling reversed() on it to get the reversed version of that Comparator.
See code below:
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());
}
}
}
If your stream elements implements Comparable
then the solution becomes simpler:
...stream()
.sorted(Comparator.reverseOrder())
In simple, using Comparator and Collection you can sort like below in reversal order using JAVA 8
import java.util.Comparator;;
import java.util.stream.Collectors;
Arrays.asList(files).stream()
.sorted(Comparator.comparing(File::getLastModified).reversed())
.collect(Collectors.toList());
You can define your Comparator with your own logic like this;
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());
};
And use it inside foreach as:
list.stream()
.sorted(sortCredentialsByLastLogin.reversed())
.collect(Collectors.toList());
For reverse sorting just change the order of x1, x2 for calling the x1.compareTo(x2) method the result will be reverse to one another
Default order
List<String> sortedByName = citiesName.stream().sorted((s1,s2)->s1.compareTo(s2)).collect(Collectors.toList());
System.out.println("Sorted by Name : "+ sortedByName);
Reverse Order
List<String> reverseSortedByName = citiesName.stream().sorted((s1,s2)->s2.compareTo(s1)).collect(Collectors.toList());
System.out.println("Reverse Sorted by Name : "+ reverseSortedByName );
You can use a method reference:
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());
In alternative of method reference you can use a lambda expression, so the argument of comparing become:
.sorted(comparing(file -> file.lastModified()).reversed());
Sort file list with java 8 Collections
Example how to use Collections and Comparator Java 8 to sort a File list.
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()));
}
}
Alternative way sharing:
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());
Instead of all these complications, this simple step should do the trick for reverse sorting using Lambda .sorted(Comparator.reverseOrder())
Arrays.asList(files).stream()
.filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
.sorted(Comparator.reverseOrder()).skip(numOfNewestToLeave)
.forEach(item -> item.delete());
Use
Comparator<File> comparator = Comparator.comparing(File::lastModified);
Collections.sort(list, comparator.reversed());
Then
.forEach(item -> item.delete());
If you want to sort by Object's date type property then
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
Source: Stackoverflow.com