[Java] Stream API - Traitement intermédiaire de flux

Traitement intermédiaire de flux

• Traiter et filtrer les valeurs circulant dans le flux
• Il est exécuté ** lorsque le processus de terminaison est appelé **

Filtrer les valeurs selon des conditions spécifiées

• ** méthode de filtrage **

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of(
      "https://qiita.com/",
      "Neko",
      "CAT",
      "https://www.amazon.co.jp/",
      "https://ja.wikipedia.org/wiki/Neko_(%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2)"
    )
      .filter(s -> s.startsWith("https://"))
      .forEach(System.out::println);
/*
https://qiita.com/
https://www.amazon.co.jp/
https://ja.wikipedia.org/wiki/Neko_(%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2)
*/
  }
}

Traiter la valeur donnée

• ** méthode de la carte **
• Convertir la liste de chaînes en liste de longueur de chaîne et en sortie
• Immédiatement après avoir été généré, il devient String <String>, et après avoir traversé la méthode map, il devient String <Integer>.

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .map(s -> s.length())
    .forEach(System.out::println); //8 7 7 13 4
  }
}

• Générer un flux de type de base ** méthode mapToInt / mapToLong / mapToDouble **
• IntStream est généré à la place de String <Integer>
• Fardeau de boxe réduit

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .mapToInt(s -> s.length())
    .forEach(System.out::println); //8 7 7 13 4
  }
}

Traiter un élément donné

• ** Méthode flatMap / flatMapToXX **
• La différence avec la carte est que le résultat de la conversion est ** renvoyé en tant que type de flux **.
• Les flux retournés par des éléments individuels sont finalement combinés et renvoyés

//Convertir une liste de tableaux à deux dimensions en un tableau à une dimension
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {

    var list = new String[][] {
      { "neko", "nekko", "nekkko" },
      { "inu", "innu" },
      { "tori", "torri" }
    };
    //Passer un tableau imbriqué avec flatMap et Arrays.Diffuser avec la méthode de flux
    //Aplatir en un tableau unidimensionnel en se connectant à flatMap
    Arrays.stream(list)
      .flatMap(v -> Arrays.stream(v))
      .forEach(System.out::println);
     // neko nekko nekkko inu innu tori torri
    }
}

• Il est également possible de traiter les valeurs de manière imbriquée lors du traitement du flux **

//Extraire l'acronyme lors de l'aplatissement d'un tableau à deux dimensions
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {

    var list = new String[][] {
      { "neko", "nekko", "nekkko" },
      { "inu", "innu" },
      { "tori", "torri" }
    };

    Arrays.stream(list)
    .flatMap(v -> Arrays.stream(v).map(str -> str.substring(0, 1)))
    .forEach(System.out::println);
    //n n n i i t t
    }
}

Trier les éléments

• ** méthode triée **
• Trier par ordre naturel

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .sorted()
    .forEach(System.out::println);
// Munchkin
// Persian
// Scottish Fold
// Siamese
// Tama
  }
}

• Si vous souhaitez définir des règles, ** définissez avec une expression lambda **

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

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .sorted((str1, str2) -> str1.length() - str2.length())
    .forEach(System.out::println);
    // Tama
    // Siamese
    // Persian
    // Munchkin
    // Scottish Fold

    /*Ordre inverse du dictionnaire dans l'interface du comparateur
     Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
     .sorted(Comparator.reverseOrder())
     .forEach(System.out::println);
    */
  }
}

Extraire le m ~ nième élément

• ** méthode skip / limit **
• ** méthode skip **: tronquer jusqu'au mième élément
• ** méthode limite **: tronque le n + 1e et les éléments suivants

//Utilisez skip pour ignorer 4 éléments et limit pour en extraire 10 éléments.
import java.util.stream.IntStream;
public class StreamLimit {
  public static void main(String[] args) {
    IntStream.range(1, 20)
      .skip(4)
      .limit(10)
      .forEach(System.out::println); //5,6,7,8,9,10,11,12,13,14
  }
}

Supprimer les valeurs du début tout en remplissant les conditions

• ** méthode dropWhile **
• Ignorer les valeurs qui correspondent à l'expression conditionnelle
• Supprimez les nombres négatifs du début du flux
• Jusqu'au dernier ** Puisqu'il s'agit d'une valeur continue depuis le début, les nombres négatifs au milieu ne sont pas supprimés **
• → Si au milieu, retirer avec filtre

import java.util.stream.IntStream;
public class StreamDrop {
  public static void main(String[] args) {
    IntStream.of(-2, -5, 0, 3, -1, 2)
      .dropWhile(i -> i < 0)
      .forEach(System.out::println); //0,3,-1,2
  }
}

Extraire uniquement les valeurs qui remplissent les conditions depuis le début

• ** Méthode takeWhile **
• Traitez uniquement ceux qui sont négatifs depuis le début du flux
• Jusqu'au dernier ** Le traitement est une valeur continue depuis le début **

import java.util.stream.IntStream;
public class StreamTake {
  public static void main(String[] args) {
    IntStream.of(-2, -5, 0, 3, -1, 2)
      .takeWhile(i -> i < 0)
      .forEach(System.out::println); //-2,-5
  }
}

Vérifiez le statut intermédiaire du flux

• ** méthode peek **
• Un traitement arbitraire peut être inséré au milieu
• méthode peek ** n'affecte pas le flux **

//Contenu du flux de sortie avant et après le tri
import java.util.stream.Stream;
public class StreamPeek {
  public static void main(String[] args) {
    Stream.of("Poisson", "Crasse", "écho", "Kinmokusei")
      .peek(System.out::println)
      .sorted()
      .forEach(System.out::println);
  }
}

Supprimer les valeurs en double

• ** méthode distincte **
• Supprimer les valeurs en double dans le flux
• Impossible de dédupliquer en utilisant un champ spécifique d'une classe comme clé
• → Utilisez la méthode de filtrage

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Chat", "Chat", "Nekko", "Chat", "ChatChat")
      .distinct()
      .forEach(System.out::println);
    //Chat
    //Chat
    //Nekko
    //chat Chat
  }
}

• Vérifiez les doublons en utilisant le champ de nom comme clé dans la classe Person

import java.util.HashSet;
import java.util.stream.Stream;

public class StreamDistinctObj {

  public static void main(String[] args) {
    var set = new HashSet<String>();
    Stream.of(
        new Person("Yamada", 40),
        new Person("Takano", 30),
        new Person("Okawa", 35),
        new Person("Yamada", 45)
      )
      //Ajouter de la valeur à HashSet dans la méthode de filtrage
      //HashSet.La méthode add renvoie false si la valeur n'a pas pu être ajoutée (dupliquer)

      .filter(p -> set.add(p.name))
      .forEach(System.out::println);
  }
}

public class Person {
  public String name;
  public int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  @Override
  public String toString() {
    return String.format("%s（%d ans)", this.name, this.age);
  }
}

Conversion de flux de base

• ** Conversion de type avec asLongStream / asDoubleStream / LongStream **

//Conversion d'IntStream vers DoubleStream
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(1, 5)
      .asDoubleStream()
      .forEach(System.out::println);
      //1.0 2.0 3.0 4.0
  }
}

Conversion mutuelle entre les flux de type de base et de type de référence

• Du type de base au type de référence: ** méthode encadrée **
• Type de référence au type de base: ** méthode mapToObj **

//IntStream pour diffuser<Integer>Conversion en
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(1, 5)
      .boxed()
      .forEach(System.out::println);
      //1 2 3 4
      
    IntStream.range(1, 5)
      .mapToObj(Integer::valueOf)
      .forEach(System.out::println);
      //1 2 3 4
  }
}

//Stream<Integer>Convertir en IntStream
import java.util.stream.Stream;
public class StreamUnboxed {
  public static void main(String[] args) {
    Stream.of(1, 2, 3, 4)
      .mapToInt(i -> i) //Unboxing Integer → int
      .forEach(System.out::println); //1 2 3 4
    }
}