collection - ¿Cómo utilizar un lambda Java8 para ordenar una secuencia en orden inverso?

java stream size

Question

Estoy usando Java Lambda para ordenar una lista.

¿Cómo puedo ordenarlo de forma inversa?

Vi esta post , pero quiero usar java 8 lambda.

Aquí está mi código (usé * -1) como un 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());

Answer 1

Esto se puede hacer fácilmente utilizando Java 8 y el uso de un Comparator invertido.

He creado una lista de archivos a partir de un directorio, que visualizo sin clasificar, ordenados y ordenados inversamente usando un Comparador simple para la clasificación y luego invocando reverse () para obtener la versión inversa de ese Comparador.

Ver código a continuación:

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

Answer 2

Forma alternativa de compartir:

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

Answer 3

Ordenar la lista de archivos con java 8 Collections

Ejemplo de cómo usar Colecciones y Comparator Java 8 para ordenar una lista de archivos.

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

Answer 4

Puede adaptar la solución que vinculó en post envolviéndolo en una lambda:

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

tenga en cuenta que f2 es el primer argumento de Long.compare , no el segundo, por lo que el resultado se revertirá.

Answer 5

Puede usar una referencia de método:

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

Como alternativa a la referencia de método, puede usar una expresión lambda, por lo que el argumento de comparación se convierte en:

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

Answer 6

Si sus elementos de flujo implementan Comparable , la solución se vuelve más simple:

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

Answer 7

Utilizar

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

Entonces

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