[Java11] Résumé du flux -Avantages du flux-

• [Java11] Résumé du flux -Avantages du flux-
• [Java11] Stream Usage Summary -Basics-

Qu'est-ce que Stream

Cartes pour collections-Classes qui prennent en charge les opérations fonctionnelles sur un flux d'éléments, telles que la réduction des transformations. Source: Document officiel

Tout d'abord, voyons réellement

Partiellement modifié depuis Référence officielle

stream.java

final int sum = widgets.stream()
                       .filter(w -> w.getColor() == RED)
                       .mapToInt(w -> w.getWeight())
                       .sum();

Dans l'exemple ci-dessus, «widgets» est extrait de «widgets» avec «color» RED »et la somme des valeurs de« weight »est calculée. Si vous l'écrivez dans l'instruction for, ce sera comme suit.

pour déclaration.java

int sum = 0;
for (Widget w: widgets) {
    if (w.getColor() == RED) {
        sum += w.getWeight();
    }
}

Que puis-je faire?

Comme je l'ai écrit au début, Stream est "* une classe qui prend en charge les opérations fonctionnelles sur un flux d'éléments, comme la conversion de réduction de carte pour les collections. *"

--Map pour la conversion de collecte-réduire

En gros, c'est ** ce que je faisais avec l'instruction for **. Vous pouvez calculer la valeur totale ci-dessus, obtenir la valeur maximale, créer une nouvelle liste, etc.

--Supporte les opérations fonctionnelles

De nombreuses méthodes de classe Stream prennent une interface fonctionnelle comme argument. Par exemple, transmettez ** comment filtrer ** à la fonction de filtre et ** comment convertir en type entier ** à la fonction mapToInt. Stream a de nombreuses méthodes qui renvoient un nouveau Stream, et vous pouvez lui transmettre le traitement pour un traitement flexible.

Ce qui est bon?

Je pense qu'il y a deux avantages majeurs:

1. Meilleure lisibilité
2. Amélioration des performances grâce au traitement parallèle

Meilleure lisibilité

Ceci est dû au fait que la méthode d'écriture utilisant Strean est ** "déclarative" ** par rapport au code normal. Portez une attention particulière à la partie de l'exemple ci-dessus où la somme («somme») est calculée.

--Pour Stream Appelez simplement sum (). Je dis simplement ** "trouver la valeur totale" ** pour l'ensemble de données.

--Pour déclaration La valeur initiale de «sum» est définie sur 0 et les valeurs de chaque élément sont ajoutées. La valeur finale est la valeur totale. ** "Comment trouver la valeur totale" ** est implémenté.

L'instruction for est appelée ** "instructive" ** par rapport au Stream. L'écriture "déclarative" vous permet de masquer les petites implémentations et de réduire la quantité de code. C'est juste une déclaration de ce qu'il faut faire, il est donc facile de comprendre ce que vous voulez faire à partir du code. En revanche, plus le processus est compliqué, plus il est difficile à comprendre et plus il provoque des bugs.

Par expérience, que Stream soit utilisé ou non, moins le code est impératif dans une méthode, plus il est facile d'écrire du code sécurisé.

Amélioration des performances par traitement parallèle

Il existe de nombreux cas où cet avantage ne peut être obtenu. (Expérience) En effet, il est ** plus rapide de s'exécuter en série **, sauf si vous avez affaire à une très grande quantité de données.

Heureusement, tout ce que vous avez à faire pour transformer l'exécution de Strean en traitement parallèle est d'appeler parallel (). Vous pouvez maximiser les avantages du traitement parallèle en considérant ** la quantité de données ** et ** le problème de ne pas maintenir l'ordre ** au lieu du traitement parallèle dans les nuages sombres.

Les articles suivants seront utiles. Référence: Connaissance de base de l'interface fonctionnelle et de l'API Stream qui montre son vrai caractère dans l'expression lambda (3/3)

Comment écris tu

Il y a ** 3 étapes ** pour écrire un processus à l'aide de Stream.

1. Créez un flux
2. Fonctionnement intermédiaire
3. Opération de terminaison

Un exemple est le suivant.

stream.java

final int sum = widgets.stream() //Créer un flux
                       .filter(w -> w.getColor() == RED) //Fonctionnement intermédiaire
                       .mapToInt(w -> w.getWeight()) //Fonctionnement intermédiaire
                       .sum(); //Opération de terminaison

Créer un flux

Je pense qu'il est souvent créé à partir d'une collection telle que List ou Set. C'est exactement ce qu'est «widgets.stream ()». En outre, il existe des méthodes telles que la création d'un Stream à partir de plusieurs valeurs et l'utilisation de Stream.Builder.

Fonctionnement intermédiaire

filter`` mapToInt est l'opération intermédiaire. Il convertit la valeur de chaque élément et extrait l'élément en fonction de la condition. Renvoie un Stream tel que Stream <T> ou ʻIntStream`. Une chaîne de méthodes est possible car elle renvoie un Stream. Le traitement de l'opération intermédiaire n'est pas le moment où "fileter", etc. est appelé. Il est exécuté pour la première fois lorsque l'opération de terminaison est exécutée. Il s'agit d'une opération intermédiaire

public class Main {
    public static void main(String[] args) throws Exception {
        List<Widget> widgets = List.of(new Widget(RED, 10), new Widget(BLUE, 20));
        
        Stream<Widget> stream1 = widgets.stream();
        Stream<Widget> stream2 = stream1.filter(w -> w.getColor() == RED);
        System.out.println("complete filtering");
        IntStream stream3 = stream2.mapToInt(w -> w.getWeight());
        System.out.println("complete mappint to integer");
        final int sum = stream3.sum();
    }
}

class Widget {
    private Color color;
    private int weight;
    
    public Widget(Color color, int weight) {
        this.color = color;
        this.weight = weight;
    }
    public Color getColor() {
        System.out.println(color);
        return color;
    }
    public int getWeight() {
        System.out.println(weight);
        return weight;
    }
}

complete filtering
complete mappint to integer
java.awt.Color[r=255,g=0,b=0]
10
java.awt.Color[r=0,g=0,b=255]

Stream<Widget> stream1 = widgets.stream();
        
Predicate<Widget> predicate = w -> w.getColor() == RED;
Stream<Widget> stream2 = stream1.filter(predicate);
        
ToIntFunction<Widget> toIntFunction = w -> w.getWeight();
IntStream stream3 = stream2.mapToInt(toIntFunction);
        
final int sum = stream3.sum();

@FunctionalInterface
public interface ToIntFunction<T> {
    int applyAsInt​(T value);
}

class Widget {
    private Color color;
    private int weight;
    
    public Widget(Color color, int weight) {
        this.color = color;
        this.weight = weight;
    }
    
    public Color getColor() {
        return color;
    }
    
    public boolean isColorRed() {
        return color == RED;
    }
    
    public int getWeight() {
        return weight;
    }
}

final int sum = widgets.stream()
                .filter(new Predicate<Widget>() {
                    public boolean test(Widget w) {
                        return w.isColorRed();
                    }
                }) 
                .mapToInt(new ToIntFunction<Widget>() {
                    public int applyAsInt(Widget w) {
                        return w.getWeight();
                    }
                }) 
                .sum();

static class WidgetTestColorIsRed implements Predicate<Widget> {
    public boolean test(Widget w) {
        return w.isColorRed();
    }
}
static class WidgetToWeightFunction implements ToIntFunction<Widget> {
    public int applyAsInt(Widget w) {
        return w.getWeight();
    }
}

final int sum = widgets.stream()
                .filter(new WidgetTestColorIsRed())
                .mapToInt(new WidgetToWeightFunction())
                .sum();

final int sum = widgets.stream()
                .filter(w -> w.isColorRed()) 
                .mapToInt(w -> w.getWeight())
                .sum(); 

//Aucun argument
() -> "constant";

//1 argument
n -> n + 1; //Les parenthèses peuvent être omises
(n) -> 2 * n;

//2 arguments ou plus
(a, b) -> Math.sqrt(a * a + b * b);
(x, y, z) -> x * y * z;

//Plusieurs lignes
(a, b, c) -> {
     double s = (a + b + c) / 2;
     return Math.sqrt(s * (s - a) * (s - b) * (s - c));
}

final int sum = widgets.stream()
                .filter(Widget::isColorRed)
                .mapToInt(Widget::getWeight)
                .sum();