Comment inverser efficacement les flux dans Java 8 ?

Explorer les techniques d'inversion de flux dans Java 8

Lorsque vous traitez des flux dans Java 8, il n'est pas rare de rencontrer le besoin d'inverser leur ordre. Pour déterminer la bonne approche pour inverser n'importe quel flux, nous approfondissons le défi spécifique de l'inversion d'un IntStream tout en explorant des solutions supplémentaires pour inverser les flux de tout type.

Inversion IntStream :*

IntStream propose une méthode range() pour générer des entiers dans une plage spécifiée. Pour inverser la plage, ajustez simplement les arguments :

<code class="java">IntStream.range(-range, 0)</code>

Cependant, cette approche n'est pas pratique et Integer::compare ne peut pas être utilisé en raison d'erreurs du compilateur. Considérez plutôt le code suivant :

<code class="java">static IntStream revRange(int from, int to) {
    return IntStream.range(from, to)
                    .map(i -> to - i + from - 1);
}</code>

Cette méthode inverse la plage sans boxe ni tri.

Inversion générale du flux :

Il y a plusieurs façons d'inverser des flux de tout type, mais les deux nécessitent de stocker les éléments.

Inversion basée sur un tableau :

Cette méthode utilise un tableau pour stocker des éléments pour une lecture ultérieure dans ordre inverse :

<code class="java">@SuppressWarnings("unchecked")
static <T> Stream<T> reverse(Stream<T> input) {
    Object[] temp = input.toArray();
    return (Stream<T>) IntStream.range(0, temp.length)
                                .mapToObj(i -> temp[temp.length - i - 1]);
}</code>

Inversion basée sur les collecteurs :

Les collecteurs peuvent être utilisés pour accumuler des éléments dans une liste inversée :

<code class="java">Stream<T> input = ... ;
List<T> output =
    input.collect(ArrayList::new,
                  (list, e) -> list.add(0, e),
                  (list1, list2) -> list1.addAll(0, list2));</code>

Pendant que c'est efficace, cela déclenche de nombreuses insertions ArrayList.add(0, ...), entraînant une copie excessive.

Inversion efficace basée sur le collecteur :

Pour atténuer le inconvénient de la copie, pensez à utiliser un ArrayDeque, qui prend en charge des insertions efficaces à l'avant :

<code class="java">Deque<String> output =
    input.collect(Collector.of(
        ArrayDeque::new,
        (deq, t) -> deq.addFirst(t),
        (d1, d2) -> { d2.addAll(d1); return d2; }));</code>

Ce code mis à jour maintient l'efficacité de l'inversion basée sur le collecteur tout en éliminant les copies inutiles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!