[Java] Génération de flux API-Stream

Qu'est-ce que l'API Steam?

• ** Bibliothèque prenant en charge le traitement itératif **
• Extraire des éléments d'un ensemble de données (source de données) tels que des collections, des tableaux et des fals, et les transmettre au flux de processus (Stream).

Principes de base de l'API Stream

• ** Génération de flux à partir de la source de données **
• ** Traitement intermédiaire ** (extraction, traitement, etc.)
• La valeur de retour est Stream <T>
• ** Traitement de terminaison ** (sortie, agrégation, etc.)
• Une série de flux sont exécutés au moment de la fin (traitement retardé)
• Le traitement intermédiaire / de terminaison peut faire référence à la bibliothèque standard qui correspond au type.
• ** Chaîne de méthodes **: Le traitement intermédiaire / le traitement de terminaison peut être lié à partir de la génération de flux avec l'opérateur .

import java.util.ArrayList;
import java.util.Arrays;

public class StreamBasic {

//Préparation de la source de données
  public static void main(String[] args) {
    var list = new ArrayList<String>(Arrays.asList("ant", "elephant", "hamster"));

/*Traitement par flux
Génération de flux à partir d'une liste pré-préparée
ArrayList<String>Parce qu'il est basé sur
La méthode stream est également Stream<String>Renvoie un objet
*/
    list.
      stream().
      /*Traitement intermédiaire
Extraire 3 caractères ou plus avec la méthode de filtrage et convertir en majuscules avec la carte
La valeur de retour est Stream<T>
      */
      filter(s -> s.length() > 3).
      map(String::toUpperCase).
      /*Résiliation
Système la valeur donnée par la méthode forEach.out
      */
      forEach(System.out::println);//ELEPHANT HAMSTER
  }
}

Génération de flux

** Génération de flux à partir de collections et de tableaux **

• Les listes, tableaux et contenus de carte peuvent être générés par traitement de flux

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class StreamBasic2 {

//liste
  public static void main(String[] args) {
    var list = new ArrayList<String>(Arrays.asList("ant", "elephant", "hamster"));
    list.stream().forEach(System.out::println);
    // list.parallelStream().forEach(System.out::println);
    System.out.println("---------------");

//Tableau
    var data = new String[] { "Rose", "Asagao", "Tulipe" };
    Arrays.stream(data).forEach(System.out::println);
    System.out.println("---------------");

//carte
    var map = new HashMap<String, String>(
        Map.of("orange", "Mandarine", "apple", "pomme", "strawberry", "fraise"));
    map.entrySet().stream().forEach(System.out::println);
  }
}

• ** parallelStream ** Version parallèle de la méthode stream
• S'il s'agit d'une collection de cartes de liste, le traitement parallèle sera possible si stream est changé en parallelStream.
  • list.parallelStream().forEach(System.out::println)

** Génération de flux à partir d'argument / expression lambda **

• Méthode d'usine pour la génération de flux

** de méthode **

• ** Convertit l'argument de longueur variable spécifié en un flux **

import java.util.stream.Stream;

public class StreamOf {
  public static void main(String[] args) {
    var stream = Stream.of("first", "second", "third");
    stream.forEach(System.out::println); //first, second, third
  }
}

** méthode de génération **

• ** Génération de flux avec la valeur de retour de l'expression lambda spécifiée **
• ex: générer et diffuser des nombres aléatoires de 1 à 100
• Génération de flux infinie, donc explicitement interrompue dans le traitement intermédiaire / de terminaison
• Dans l'exemple suivant, limit (10) traite uniquement les 10 premiers cas.
• Méthode Random.ints lors de la génération d'un flux aléatoire dans l'application

import java.util.Random;
import java.util.stream.Stream;

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

    var stream = Stream.generate(() -> {
      var r = new Random();
      return r.nextInt(100);
    });
    stream.limit(10).forEach(System.out::println);
    //46 24 42 80 61 67 69 22 85 1
  }
}

** méthode itaterate **

• ** Génération de flux avec la valeur initiale et l'expression lambda spécifiées **
• La valeur initiale est transmise en premier, et le résultat précédent est passé après cela.
• Dans l'exemple suivant, 1 est défini comme valeur initiale et une valeur doublée est générée.

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    var stream = Stream.iterate(1, (num) -> {
      return num * 2;
    });
    stream.limit(10).forEach(System.out::println);
    //4 8 16 32 64 128 256 512
    }
}

** méthode constructeur **

• Objet Stream.Builder pour l'assemblage de flux Sincérité

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    var builder = Stream.builder()
        .add("Munchkin")
        .add("Siamese")
        .add("Persian");
      builder.build().forEach(System.out::println); 
      //Munchkin
      //Siamese
      //Persian
  }
}

** méthode concat **

• ** Combinez plusieurs flux en un seul flux pour plus de commodité **

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {

    var stream1 = Stream.of("Munchkin", "Siamese", "Persian");
    var stream2 = Stream.of("Corgi", "Poodle", "Shiba");
    Stream.concat(stream1, stream2).forEach(System.out::println);
    // Munchkin Siamese Persian 
    // Corgi Poodle Shiba
  }
}

** Générer un flux de base **

• Spécialisé pour les types de base ** IntStream / LongStream / DoubleStream **
• ** of / generate / iterate / builder factory method ** peut être utilisé
• IntStream / LongStream peut utiliser ** la méthode de plage **

//Limite supérieure Ah Non inclus dans le flux
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(10, 20)
      .forEach(System.out::println); //10 11 12 13 14 15 16 17 18 19
  }
}

• Si vous souhaitez inclure la limite supérieure, ** méthode rangeClosed **

import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.rangeClosed(10, 20)
     .forEach(System.out::println); //10 11 12 13 14 15 16 17 18 19 20
  }
}