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

Je suis en utilisant java lambda pour trier une liste.

comment puis-je trier dans le sens inverse?

J'ai vu ce post, mais je veux l'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());

Qu'entendez-vous par "ordre inverse"? Si vous remplacez -1 * answer avec answer, la commande de changement à l'inverse de ce qu'il était avec -1 * ....
Méfiez-vous! Tout votre code suggère que vous souhaitez utiliser forEachOrdered au lieu de forEach
pourquoi est-ce? pouvez-vous expliquer?
Suivez les liens. Simplement dit, forEachOrdered, comme son nom l'indique, s'occupe de la rencontre de commande, ce qui est pertinent que vous voulez sauter un certain nombre de nouveau les fichiers qui s'appuie sur le “triées par date de modification de commande”.
Je ne suis pas entièrement l'obtenir. comme le forEach dans mon exemple qui se passe après la skip. sens après mon filtre, je ne se soucient pas de l'ordre
Un peu en retard, je tiens à souligner que votre compréhension de la façon sort→skip→(non ordonnée)forEach devrait fonctionner, est correct et qu'il est en effet mis en place pour travailler de cette façon aujourd'hui, dans le Jre, mais de retour en 2015, lorsque les commentaires précédents ont été faits, il a été en effet un problème (comme vous pourrez le lire dans cette question).

InformationsquelleAutor Elad Benda2 | 2015-02-19

183

Vous pouvez adapter la solution que vous avez lié à Comment trier ArrayList<Long> en Java, dans l'ordre décroissant? en l'enveloppant dans un lambda:

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

noter que f2 est le premier argument de Long.compare, pas la seconde, de sorte que le résultat sera inversé.
- ... ou Comparator.comparingLong(File::lastModified).reversed()
- Flux de la Chaîne, et d'avoir comparingLong(v->Long.valueOf(v)).reversed() jette erreur de compilation: java.lang.valueOf(java.lang.String) cannot be used on java.lang.valueOf(java.lang.Object). Pourquoi?
- voir Comparateur.inversé() ne permet pas de compiler à l'aide de lambda. Vous pouvez essayer de comparingLong(Long::valueOf).reversed() à la place. Ou Collections.reverseOrder(comparingLong(v->Long.valueOf(v)))
- merci pour le lien. Mais l'Stuart "pas entièrement sûr de savoir pourquoi". J'étais confus quand j'ai vu les deux méthodes font référence T au lieu de Object, sens le type d'objet ne doit pas être perdu. Mais en réalité il est. C'est ce que je suis confus au sujet de.
- Eh bien, Brian Goetz’ commentaire explique la différence. J'ai été surpris aussi que Stuart ne savais pas que la “cible en tapant” ne fonctionne pas à travers enchaîné les invocations, mais d'un autre côté, c'était en 2014. Voir ici pour plus de détails.
- si enchaînés dans le style causer de type perdre, comment peut-on écrire le générateur de modèle?
- c'est la rétro-propagation de la type de cible qui ne fonctionne pas. Si l'expression initiale de votre chaîne a un type autonome, il fonctionne par le biais de la chaîne comme il l'a fait avant Java 8. Comme vous pouvez le voir avec le comparateur exemple, en utilisant une méthode de référence, c'est à dire comparingLong(Long::valueOf).reversed() œuvres, de même explicitement tapé par l'expression lambda fonctionne comparingLong((String v) -> Long.valueOf(v)).reversed() œuvres. Aussi Stream.of("foo").mapToInt(s->s.length()).sum() œuvres, comme le "foo" fournit le type autonome alors que Stream.of().mapToInt(s-> s.length()).sum() échoue.
- Downvoted parce que de ne pas mentionner reversed() (voir les commentaires, et d'autres solutions). Heureux de transformer cela en un upvote si corrigée.
InformationsquelleAutor Adrian Leonhard
115

Si votre flux éléments implémente Comparable alors la solution devient de plus simple:
```
 ...stream()
 .sorted(Comparator.reverseOrder())
```
- c'est la solution la plus élégante pour moi
- Meilleure réponse, +1
- meilleure réponse, merci
- ou ...stream().max(Comparator.naturalOrder())
- Pour la plus récente de l'élément dans une collection de la comparaison par date .stream().max(Comparator.comparing(Clazz::getDate))
InformationsquelleAutor GKislin
49

Utilisation
```
Comparator<File> comparator = Comparator.comparing(File::lastModified); 
Collections.sort(list, comparator.reversed());
```
Puis
```
.forEach(item -> item.delete());
```
- Eh bien, il a demandé à propos de cours d'eau, mais j'aime votre réponse tout de même.
- Ce n'est pas "fonctionnel" façon de faire... il a des effets secondaires!!
InformationsquelleAutor Vishnudev K

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

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

Dans la variante de la méthode de référence, vous pouvez utiliser une expression lambda, donc l'argument de la comparaison de devenir:

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

InformationsquelleAutor iFederx

Autre moyen de partage:

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

InformationsquelleAutor Chang

Cela peut facilement être fait à l'aide de Java 8 et l'utilisation de l'inversion de la Comparateur.

J'ai créé une liste de fichiers d'un répertoire, qui, je l'affichage non triés, classés et inverse triés à l'aide d'un simple Comparateur pour les trier, puis en appelant inversé() sur elle pour obtenir la version inversée de ce Comparateur.

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

InformationsquelleAutor ManoDestra

Trier la liste des fichiers avec java 8 Collections

Exemple, comment utiliser les Collections et Comparateur de 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()));
}
}

InformationsquelleAutor Jonathan Mendoza

Vous devez vous connecter pour publier un commentaire.