Wie verwende ich ein Java8-Lambda, um einen Stream in umgekehrter Reihenfolge zu sortieren?

Ich benutze Java Lambda, um eine Liste zu sortieren.

Wie kann ich es umgekehrt sortieren?

Ich habe diesen Beitrag gesehen , möchte aber Java 8 Lambda verwenden.

Hier ist mein Code (ich habe * -1 verwendet) als 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());

Sie können die in Wie sortiere ich ArrayList <Long> in Java verknüpfte Lösung in absteigender Reihenfolge anpassen ? indem man es in ein Lambda einwickelt:

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

Beachten Sie, dass f2 das erste Argument von Long.compareund nicht das zweite ist, sodass das Ergebnis umgekehrt wird.

Wenn Ihre Stream-Elemente implementiert werden, Comparablewird die Lösung einfacher:

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

Verwenden

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

Dann

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

Sie können eine Methodenreferenz verwenden:

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

Alternativ zur Methodenreferenz können Sie einen Lambda-Ausdruck verwenden, sodass das Argument des Vergleichs zu:

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

Alternative Wege teilen:

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

Dies kann leicht mit Java 8 und einem umgekehrten Komparator durchgeführt werden .

Ich habe eine Liste von Dateien aus einem Verzeichnis erstellt, die ich mit einem einfachen Komparator für die Sortierung unsortiert, sortiert und umgekehrt sortiert anzeige und dann reversed () aufrufe, um die umgekehrte Version dieses Komparators zu erhalten.

Siehe Code unten:

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

Sortieren Sie die Dateiliste mit Java 8 Collections

Beispiel für die Verwendung von Collections and Comparator Java 8 zum Sortieren einer Dateiliste.

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

Mit Comparator und Collection können Sie mit JAVA 8 ganz einfach in umgekehrter Reihenfolge sortieren

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

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

Für die umgekehrte Sortierung ändern Sie einfach die Reihenfolge von x1, x2, um die Methode x1.compareTo (x2) aufzurufen. Das Ergebnis ist umgekehrt

Standardreihenfolge

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

Umgekehrte Reihenfolge

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