Terminaison de flux

Enfin sortie ou agréger les valeurs traitées / filtrées par le traitement du flux
** Les flux sont traités avec le traitement de fin comme déclencheur **
Le traitement de la résiliation ** ne peut pas être omis **
cf: le traitement intermédiaire peut être omis
Le flux ne peut pas être réutilisé après l'arrêt (IllegalStateException)

Eléments de processus en séquence

** forEach méthode **
Vous pouvez passer la référence de méthode System.out :: println telle quelle ou sous forme d'expression lambda.

import java.util.stream.Stream;
public class StreamForEach {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Tama")
    .forEach(v -> System.out.println(v));
  }
}

La méthode forEach ** ne garantit pas l'ordre dans les flux parallèles! ** **
→ Utilisez la méthode ** forEachOrdered ** pour conserver l'ordre!

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Tama")
    .parallel()
    .forEach(v -> System.out.println(v));
    //Persian Tama Siamese Munchkin 
    
    /*Si vous souhaitez conserver la commande
    .forEachOrdered(v -> System.out.println(v)); 
    Munchkin Siamese Persian Tama
    */
  }
}

Obtenez la première valeur

** méthode findFirst **
La valeur de retour est ** Type facultatif ** car le flux peut provenir

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    var str = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .findFirst();
      //Si la méthode orElse est nulle"-"Remplacer par
      System.out.println(str.orElse("－")); //Siamese
  }
}

** La méthode findAny ** renvoie le premier résultat obtenu * dans un flux parallèle **, le résultat peut donc changer.

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    var str = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .parallel()
    .filter(s -> s.startsWith("S"))
    .findAny();
     System.out.println(str.orElse("－")); //Scottish Fold
  }
}

Déterminer si la valeur répond à certaines conditions

** Méthode anyMatch / allMatch / noneMatch **

//Vérifiez si toutes les valeurs de la liste sont égales ou supérieures à 0
import java.util.stream.IntStream;

public class StreamMatch {

  public static void main(String[] args) {
    System.out.println(
        IntStream.of(1, 10, 5, -5, 12)
          .allMatch(v -> v >= 0)
      ); //false
  }
}

Convertir en tableau / collection

** Méthode toArray **
Obtenez le résultat du traitement du flux sous forme de tableau de chaînes

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    var list = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .toArray();
    System.out.println(list[0]); //Siamese
  }
}

** Convertir en collection avec la méthode de collecte **
Convertir les résultats du traitement du flux en une liste
** toList **: Convertir en liste
** toSet **: Convertir en set
** toMap **: Convertir en carte
** toCollection **: Conversion en collection générale

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTrans2 {

  public static void main(String[] args) {
    var list = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .collect(Collectors.toList());
    System.out.println(list);
  }
}

** Méthode toMap **
Définissez l'argument de fusion s'il y a une possibilité de duplication (IllegalStateException)

//Nommez le tableau d'objets Person:Convertir au format de carte d'adresse e-mail
public class StreamCollectMap {

  public static void main(String[] args) {
    System.out.println(
        Stream.of(
          new Person("Yamada Taro", "[email protected]"),
          new Person("Hanako Suzuki", "[email protected]"),
          new Person("Saburo Inoue", "[email protected]"),
          new Person("Kumi Sato", "[email protected]"),
          new Person("Yamada Taro", "[email protected]")
        ).collect(Collectors.toMap(
          //La clé d'argument représente la clé de la carte
          Person::getName,
          //La valeur de l'argument représente la clé de la carte
          Person::getEmail,
          //Lorsqu'il y a une possibilité de duplication
          (s, a) -> s + "/" + a
          //Écraser la valeur lors de la duplication
          // (s, a) ->  a
        ))
      );
  }
}

public class Person {
  private String name;
  private String email;
  public Person(String name, String email) {
    this.name = name;
    this.email = email;
  }
  public String getName() {
    return name;
  }
  public String getEmail() {
    return email;
  }
}

Trouvez le maximum et le minimum

** Méthode min.max **
Type de comparateur comme argument
Trier par ordre naturel
Étant donné que la valeur de retour est un type facultatif, ** méthode orElse ** pour la récupération de valeur

import java.util.Comparator;
import java.util.stream.Stream;

public class StreamMin {

  public static void main(String[] args) {
    var str = Stream.of("Mebaru", "Sanma", "Inspiration", "Iwashi", "Hokke")
        .min(Comparator.naturalOrder());
      System.out.println(str.orElse("")); //Iwashi
  }
}

Trouvez le nombre d'éléments

** méthode de comptage **

//Trouvez le nombre de chaînes supérieur à la longueur de la chaîne 3.
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
      .filter(s -> s.length() > 7)
      .count() //2
    );
  }
}

Trouvez la valeur totale / moyenne

** méthode somme / moyenne **
Uniquement disponible pour les flux de base
La valeur de retour de la méthode moyenne est ** FacultatifDouble type **
Extrait avec la méthode orElse

//Somme du tableau int, moyenne
import java.util.stream.IntStream;

public class StreamSum {

  public static void main(String[] args) {
    var list = new int[] { 5, 1, 10, -3 };
    System.out.println(IntStream.of(list).sum()); //13
    System.out.println(IntStream.of(list).average().orElse(0)); //3.25
  }
}

Combinez les valeurs de flux en une seule

** Réduction **
La méthode max / min / count est également réduite
** Méthode de réduction ** pour une réduction à usage général

Avec un argument:

Arguments reçus par la méthode de réduction (expression lambda)
** Variable de stockage du résultat de l'opération ** (résultat)
** Variables pour recevoir des éléments individuels ** (str)

//Grouper les flux de chaînes séparés par des virgules
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        .reduce((result, str) -> {
          return result + "," + str;
        })
        .orElse("") //Munchkin,Persian,Scottish Fold,Siamese,Tama
    );
  }
}

Avec 2 arguments:

Vous pouvez recevoir la valeur initiale
Le résultat est non nul, donc non facultatif
La valeur peut être obtenue sans passer par orElse
Dans les flux parallèles, le résultat change car la valeur initiale est appliquée à l'expression lambda par la quantité distribuée.
Il existe une possibilité de duplication des valeurs initiales en raison de la parallélisation

import java.util.stream.Stream;
public class StreamReduce2 {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        // .parallel()
        .reduce("Himalayan", (result, str) -> {
          return result + "," + str;
        })
    ); //Himalayan,Munchkin,Persian,Scottish Fold,Siamese,Tama
  }
}

Avec 3 arguments:

Utilisé lorsque le type d'élément Stream et ** le type de résultat final sont différents **
Lors de l'obtention d'éléments individuels avec réduire, le résultat de l'opération (résultat) et la variable (valeur) de chaque élément sont ** différents types sont OK **
Ajoutez la valeur de chaîne de caractères convertie en valeur numérique au résultat de l'argument (Integer)

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("153", "211", "112", "350", "418", "208")
        .parallel()
        .reduce(0,
          //Obtenez des éléments individuels
          //Le résultat de l'opération est stocké dans result et value reçoit chaque élément.
          (result, value) -> {
            return result + Integer.parseInt(value); //Convertir la valeur de la chaîne en nombre
          },
          //Résumer les résultats distribués(Flux parallèle uniquement)
          (result1, result2) -> {
            return result1 + result2; //1452
          }
      )
    );
  }
}

Collecter des éléments de flux dans une collection (1)

** méthode de collecte **
** Réduction de variable **: stocke et renvoie des valeurs dans un conteneur de variable (conteneur) tel qu'une collection ou StringBuilder
cf: réduire combine les éléments d'un flux en un ** type unique comme int / String **

//Trier un flux de chaînes donné et le convertir en liste
import java.util.ArrayList;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama"
        .sorted()
        .collect(
          //Création d'un conteneur qui stocke la valeur dans la première valeur de réduction par le nombre d'expressions
          ArrayList<String>::new,
          //Les arguments sont des conteneurs, des éléments individuels
          (list, str) -> list.add(str),
          //Pour les flux parallèles
          (list1, list2) -> list1.addAll(list2)
        )
    );
  }
}

Collecter des éléments de flux dans une collection (2)

** La méthode de collecte a une surcharge **
Peut être généré avec la méthode statique Collector.of
Attribut collecteur
** CONCURRENT **: L'accumulateur peut être exécuté dans plusieurs threads
** UNORDERED **: Ne garantit pas l'ordre des éléments
** IDENTITY_FINISH **: le module de finition peut être omis

import java.util.ArrayList;
//import java.util.Arrays;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        .collect(
          Collector.of(
            ArrayList::new,
            ArrayList::add,
            (list1, list2) -> {
              list1.addAll(list2);
              return list1;
            },
            Collector.Characteristics.IDENTITY_FINISH
          )
        )
    );
  }
}

Collecteur standard

La classe Collectors a une méthode de fabrique qui crée un collecteur qui peut être utilisé avec la méthode collect
** Implémentez facilement le traitement de rédaction typique! ** **
Les méthodes ToList et toMap sont également incluses dans la méthode d'usine

méthode de jonction

Génération de collection de jointures de chaîne

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(Collectors.joining(",", "<", ">")) //<Munchkin,Persian,Scottish Fold,Siamese,Tama>
      );
  }
}

méthode groupingBy

Génération de collecteur pour regrouper les valeurs par clé spécifiée

//Catégoriser les chaînes par longueur
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
          //Recevoir le type d'élément avec l'argument str et générer la clé de regroupement
          //Grouper par chaîne
            Collectors.groupingBy(str -> str.length()
          )) //{4=[Tama], 7=[Persian, Siamese], 8=[Munchkin], 13=[Scottish Fold]}
      );
  }
}

** Traiter les résultats groupés dans un autre collecteur **
Spécifiez un argument pour rejoindre

public class Main {

  public static void main(String[] args) {
      
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.groupingBy(
              str -> str.length(),
              Collectors.joining("/") //{4=Tama, 7=Persian/Siamese, 8=Munchkin, 13=Scottish Fold}
          ))
      );
  }
}

méthode partitioningBy

** Regroupement simple à diviser en vrai / faux **

//Séparez selon que la chaîne de caractères est de 7 caractères ou moins ou longue
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
      
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.partitioningBy(
              str -> str.length() > 7
          ) //{false=[Persian, Siamese, Tama], true=[Munchkin, Scottish Fold]}
        )
      );
  }
}

Méthode de collecteAndThen

Exécution du traitement de résiliation après l'exécution du collecteur
Concaténer le collecteur et le post-traitement

//Répertorier les flux avec la méthode toList
//Collections::Convertir en lecture seule avec unmodifiableList

import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.collectingAndThen(
              Collectors.toList(),
              Collections::unmodifiableList
            )
          )
      );
  }
}

Classe IntSummaryStatistics

Obtenez des statistiques numériques de base
La valeur de retour de la méthode collect est l'objet (Int) SummaryStatistics
Obtenez des statistiques avec la méthode getter
** getAverage () **: valeur moyenne (0 s'il n'y a pas de valeur)
** getCount () **: Nombre d'éléments
** getMax () **: Maximum
** getMin () **: Minimum
** getSum () **: Total (0 si aucune valeur)

import java.util.IntSummaryStatistics;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    var summary = IntStream.of(5, 13, 7, 2, 30)
      .collect(
     //Passer une référence au sod parseInt dans le constructeur, accepter, combinerDB
        IntSummaryStatistics::new,
        IntSummaryStatistics::accept,
        IntSummaryStatistics::combine
      );
    System.out.println(summary.getMin()); //2
    System.out.println(summary.getSum()); //57
    System.out.println(summary.getAverage()); //11.4
  }
}

[Java] Stream API - Traitement de l'arrêt du flux

Terminaison de flux

Eléments de processus en séquence

Obtenez la première valeur

Déterminer si la valeur répond à certaines conditions

Convertir en tableau / collection

Trouvez le maximum et le minimum

Trouvez le nombre d'éléments

Trouvez la valeur totale / moyenne

Combinez les valeurs de flux en une seule

Avec un argument:

Avec 2 arguments:

Avec 3 arguments:

Collecter des éléments de flux dans une collection (1)

Collecter des éléments de flux dans une collection (2)

Collecteur standard

** méthode de jonction **

** méthode groupingBy **

** méthode partitioningBy **

** Méthode de collecteAndThen **

** Classe IntSummaryStatistics **

méthode de jonction

méthode groupingBy

méthode partitioningBy

Méthode de collecteAndThen

Classe IntSummaryStatistics