Obtenez le dernier élément de Stream / List en une seule ligne

Comment puis-je obtenir le dernier élément d'un flux ou d'une liste dans le code suivant?

Où data.careasest un List<CArea>:

CArea first = data.careas.stream()
                  .filter(c -> c.bbox.orientationHorizontal).findFirst().get();

CArea last = data.careas.stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .collect(Collectors.toList()).; //how to?

Comme vous pouvez le voir, obtenir le premier élément, avec un certain filter, n'est pas difficile.

Cependant, obtenir le dernier élément d'un one-liner est une vraie douleur:

• Il semble que je ne puisse pas l'obtenir directement à partir d'un fichier Stream. (Cela n'aurait de sens que pour les flux finis)
• Il semble également que vous ne pouvez pas obtenir des choses comme first()et à last()partir de l' Listinterface, ce qui est vraiment pénible.

Je ne vois aucun argument pour ne pas fournir une méthode first()and last()dans l' Listinterface, car les éléments y sont ordonnés et de plus la taille est connue.

Mais selon la réponse originale: comment obtenir le dernier élément d'un fini Stream?

Personnellement, c'est le plus proche que je puisse obtenir:

int lastIndex = data.careas.stream()
        .filter(c -> c.bbox.orientationHorizontal)
        .mapToInt(c -> data.careas.indexOf(c)).max().getAsInt();
CArea last = data.careas.get(lastIndex);

Cependant, cela implique l'utilisation d'un indexOfélément sur chaque élément, ce qui n'est probablement pas souhaité car cela peut nuire aux performances.

Il est possible d'obtenir le dernier élément avec la méthode Stream :: reduction . La liste suivante contient un exemple minimal pour le cas général:

Stream<T> stream = ...; // sequential or parallel stream
Optional<T> last = stream.reduce((first, second) -> second);

Cette implémentation fonctionne pour tous les flux ordonnés (y compris les flux créés à partir de listes ). Pour non ordonné flux , c'est pour des raisons évidentes non spécifiées quel élément sera retourné.

L'implémentation fonctionne pour les flux séquentiels et parallèles . Cela peut être surprenant à première vue, et malheureusement la documentation ne l'indique pas explicitement. Cependant, c'est une caractéristique importante des flux, et j'essaye de la clarifier:

• Le Javadoc de la méthode Stream :: reduction indique qu'il "n'est pas contraint de s'exécuter séquentiellement " .
• Le Javadoc exige également que la "fonction d'accumulateur soit une fonction associative , non interférente et sans état pour combiner deux valeurs" , ce qui est évidemment le cas pour l'expression lambda(first, second) -> second .
• Le Javadoc pour les opérations de réduction déclare: "Les classes de flux ont plusieurs formes d'opérations de réduction générales, appelées réduire () et collect () [..]" et "une opération de réduction correctement construite est intrinsèquement parallélisable , tant que la fonction (s ) utilisés pour traiter les éléments sont associatifs et sans état . "

La documentation des Collecteurs étroitement liés est encore plus explicite: "Pour s'assurer que les exécutions séquentielles et parallèles produisent des résultats équivalents , les fonctions de collecteur doivent satisfaire une contrainte d' identité et d' associativité ."

Retour à la question d'origine: Le code suivant stocke une référence au dernier élément de la variable lastet lève une exception si le flux est vide. La complexité est linéaire dans la longueur du flux.

CArea last = data.careas
                 .stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .reduce((first, second) -> second).get();

Si vous avez une collection (ou plus généralement un Iterable), vous pouvez utiliser Google Guava

Iterables.getLast(myIterable)

comme oneliner pratique.

Une doublure (pas besoin de flux;):

Object lastElement = list.get(list.size()-1);

Guava a une méthode dédiée pour ce cas:

Stream<T> stream = ...;
Optional<T> lastItem = Streams.findLast(stream);

C'est équivalent à stream.reduce((a, b) -> b) mais les créateurs affirment que ses performances sont bien meilleures.

De la documentation :

Le runtime de cette méthode sera entre O (log n) et O (n), fonctionnant mieux sur les flux séparables efficacement.

Il convient de mentionner que si le flux n'est pas ordonné, cette méthode se comporte comme findAny().

Si vous avez besoin d'obtenir le dernier nombre d'éléments N. La fermeture peut être utilisée. Le code ci-dessous maintient une file d'attente externe de taille fixe jusqu'à ce que le flux atteigne la fin.

    final Queue<Integer> queue = new LinkedList<>();
    final int N=5;
    list.stream().peek((z) -> {
        queue.offer(z);
        if (queue.size() > N)
            queue.poll();
    }).count();

Une autre option pourrait être d'utiliser une opération de réduction en utilisant l'identité comme file d'attente.

    final int lastN=3;
    Queue<Integer> reduce1 = list.stream()
    .reduce( 
        (Queue<Integer>)new LinkedList<Integer>(), 
        (m, n) -> {
            m.offer(n);
            if (m.size() > lastN)
               m.poll();
            return m;
    }, (m, n) -> m);

    System.out.println("reduce1 = " + reduce1);

Vous pouvez également utiliser la fonction skip () comme ci-dessous ...

long count = data.careas.count();
CArea last = data.careas.stream().skip(count - 1).findFirst().get();

c'est super simple à utiliser.