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

Estoy usando Java Lambda para ordenar una lista.

¿Cómo puedo ordenarlo de forma inversa?

Vi esta publicación , 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());

Puede adaptar la solución que vinculó en Cómo ordenar ArrayList <Long> en Java en orden decreciente? 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á.

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

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

Utilizar

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

Luego

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

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

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

Esto se puede hacer fácilmente utilizando Java 8 y el uso de un comparador 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 invertido () 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());
        }
    }
}

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

En simple, utilizando Comparador y la colección se puede ordenar como a continuación en la inversión para el uso de Java 8

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

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

Para la clasificación inversa, simplemente cambie el orden de x1, x2 para llamar al método x1.compareTo (x2), el resultado será inverso entre sí

Orden predeterminada

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

Orden inverso

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