web-dev-qa-db-fra.com

Comment utiliser un lambda Java8 pour trier un flux dans l'ordre inverse?

J'utilise Java lambda pour trier une liste.

comment puis-je le trier de manière inverse?

J'ai vu ceci post , mais je veux utiliser Java 8 lambda.

Voici mon code (j'ai utilisé * -1) comme 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());
javalambdajava-8java-stream
142
Elad Benda2

Vous pouvez adapter la solution que vous avez liée en comment trier ArrayList <Long> en Java par ordre décroissant? en l’enveloppant dans un lambda:

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

notez que f2 est le premier argument de Long.compare, pas le second, ainsi le résultat sera inversé.

187
Adrian Leonhard

Si vos éléments de flux implémentent Comparable alors la solution devient plus simple:

 ...stream()
 .sorted(Comparator.reverseOrder())
120
GKislin

Utilisation

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

Ensuite

.forEach(item -> item.delete());
50
Vishnudev K

Vous pouvez utiliser une référence de méthode:

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

En alternative à la référence de la méthode, vous pouvez utiliser une expression lambda. L'argument de comparaison devient:

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

Partage alternatif:

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

Cela peut facilement être fait en utilisant Java 8 et en utilisant un inversé Comparateur .

J'ai créé une liste de fichiers à partir d'un répertoire, que j'affiche sans tri, trié et trié inversement à l'aide d'un simple comparateur pour le tri, puis en appelant reverse () dessus pour obtenir la version inversée de ce comparateur.

Voir le code ci-dessous:

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

Trier la liste de fichiers avec Java 8 Collections

Exemple d'utilisation de Collections and Comparator Java 8 pour trier une liste de fichiers.

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