Traitement des listes à comprendre avec des images - java8 stream / javaslang-

J'entends souvent "j'ai essayé le stream avec java8, mais je n'y suis pas habitué" ou "je ne peux pas le faire si j'essaye de faire quelque chose d'un peu difficile", donc je vais le résumer.

Il semble que si vous saisissez le type, vous pouvez comprendre 80%, alors je vais essayer d'en faire une image.

~~ Au fait, l'article est long, mais il suffit de lire le premier titre [histoire principale -)! ~~

C'est trop long pour réfléchir calmement, alors je l'ai divisé.

[Main story --java8 stream]: filtrer, cartographier, réduire

Maintenons les trois mains de base.

Vous n'êtes peut-être pas familier avec reduction, mais c'est un modèleMapReduce préconisé par Google, donc vous pouvez parler avec map. -> wiki

Regardons cela en utilisant l'exemple ci-dessous.

/*
 *Il y a le journal suivant
 *Étiquette ou étiquette:Sortie ligne par ligne au format millisec
 *
 *Trouvez la somme des millisecondes
 */
List<String> lines = Arrays.asList(
    "application-boot", "access-dispatch:10", "dispatched", "authentication:30", "database-access:45", "response-creation:15", "access-logging"
);

L'important est le type, alors n'ayez pas peur des génériques et vérifiez-le.

Ensuite, beaucoup de ces images sortiront.

ʻA-> B fest écrit en code java commeB f (a); et ʻA et B sont String et ʻOptional . Contient un type spécifique tel que `. En d'autres termes, les génériques.

filter La définition de «filtre» est la suivante.

Stream<T> filter(Predicate<? super T> predicate);

Oubliez Predicate <T> que l'argument est T et la valeur de retour est bool, et? Super T.

Prenons la notation de type Predicate <T> comme T to bool et écrivons (T-> bool). Au fait, simplifions également les génériques.

Stream<T> filter((T -> bool) f);

Pour utiliser filter pour créer des lignes uniquement des lignes avec: `, vous pouvez écrire:

lines.stream()
        .filter(line -> line.contains(":"))                  // ["access-dispatch:10", "authentication:30", "database-access:45", "response-creation:15"]

Si vous écrivez la définition comme T-> bool, l'implémentation line-> line.contains (": ") a la même apparence. (Dans ce sujet, «T» est spécifiquement «String»)

Est-ce comme ça lorsqu'il est dessiné dans une image?

filtre signifie que le ** type ** ne change pas, mais que le ** nombre ** change.

map La définition de «map» est la suivante.

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Ceci est également simplifié de la même manière.

Stream<R> map((T -> R) f);

Utiliser map pour changer la ligne de label: millisec en ʻInteger peut être écrit après filter` comme suit.

lines.stream()
        .filter(line -> line.contains(":"))                  // ["access-dispatch:10", "authentication:30", "database-access:45", "response-creation:15"]
        .map(line -> Integer.valueOf(line.split(":")[1]))    // [10, 30, 45, 15]

Ici aussi, l'implémentation a la même forme que la définition «T-> R». (Dans ce sujet, R est spécifiquement ʻInteger, donc ce serait bien si T-> R ressemble à String-> Integer`)

Est-ce comme ça lorsqu'il est dessiné dans une image?

map signifie que le ** nombre ** ne change pas, mais que le ** type ** change.

reduce Il existe trois définitions de «réduire» dans le flux java8, mais c'est ce que je vais utiliser maintenant.

T reduce(T identity, BinaryOperator<T> accumulator);

BinaryOperator <T> est un peu inconnu, mais cela signifie "deux arguments sont T et la valeur de retour est" T` ". Simplifions cela sans avoir peur.

T reduce(T t, ((T, T) -> T) f);

«réduire» est généralement appelé «convolution», et c'est un processus d'accumulation des résultats dans l'ordre à partir du haut de la liste.

En utilisant reduction pour faire de la ligne ʻInteger la somme de ʻInteger peut être écrite dans la suite de map comme suit.

lines.stream()
        .filter(line -> line.contains(":"))                  // ["access-dispatch:10", "authentication:30", "database-access:45", "response-creation:15"]
        .map(line -> Integer.valueOf(line.split(":")[1]))    // [10, 30, 45, 15]
        .reduce(0, (acc, n) -> acc + n)                      // 100

Il y a quelques parenthèses dans la définition, mais cela devrait être un peu plus facile à comprendre car T, (T, T) -> T et 0, (acc, n) -> ... ont la même forme.

Est-ce comme ça lorsqu'il est dessiné dans une image?

réduire est un processus dans lequel les ** éléments de liste ** deviennent ** un seul résultat **.

Résumé

C'est clair!

 *Trouvez la somme des millisecondes

Est

// (Republier)

lines.stream()
        .filter(line -> line.contains(":"))                  // ["access-dispatch:10", "authentication:30", "database-access:45", "response-creation:15"]
        .map(line -> Integer.valueOf(line.split(":")[1]))    // [10, 30, 45, 15]
        .reduce(0, (acc, n) -> acc + n)                      // 100

Je l'ai résolu avec.

Pour le moment, je posterai la photo complète.

fin

Tous les extras à partir de maintenant ont été séparés dans les articles suivants.

Traitement de la liste compris par les images --java8 stream / javaslang --bonus

Rafraîchissant.