Vraag Hoe een Java8 lambda te gebruiken om een ​​stream in omgekeerde volgorde te sorteren?


Ik gebruik java lambda om een ​​lijst te sorteren.

hoe kan ik het op een andere manier sorteren?

ik zag dit post, maar ik wil Java 8 lambda gebruiken.

Hier is mijn code (ik gebruikte * -1) als een 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());

96
2018-02-19 13:04


oorsprong


antwoorden:


U kunt de oplossing aanpassen waarin u bent gelinkt Hoe ArrayList <Long> in afnemende volgorde in Java te sorteren? door het in een lambda te verpakken:

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

Let daar op f2 is het eerste argument van Long.compare, niet de tweede, dus het resultaat zal worden omgekeerd.


142
2018-02-19 13:08



BTW: als je stream elementen implementeert Comparable dan is het simpel geworden:

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

61
2018-03-15 15:48



Gebruik

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

Dan

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

37
2018-02-19 13:08



U kunt een methodeverwijzing gebruiken:

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

Als alternatief voor referentie van de methode kun je een lambda-uitdrukking gebruiken, dus het argument om te vergelijken wordt:

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

25
2017-09-09 23:35



Alternatieve manier van delen:

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

7
2017-12-01 03:11



Dit kan eenvoudig worden gedaan met behulp van Java 8 en het gebruik van een omgekeerde Comparator.

Ik heb een lijst gemaakt van bestanden uit een directory, die ik ongesorteerd, gesorteerd en omgekeerd gesorteerd weergeef met behulp van een eenvoudige Comparator voor het sorteren en daarna omgekeerd () aanroepen om de omgekeerde versie van die Comparator te krijgen.

Zie onderstaande code:

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

3
2018-05-02 21:42