[Java11] Résumé de l'utilisation du flux -Basics-

introduction

Cela fait environ deux ans que j'ai écrit Java, et récemment je l'ai implémenté dans Java 11. De Java 8 à 9,10 à Stream et facultatif Certaines méthodes ont également été ajoutées à https://docs.oracle.com/javase/jp/11/docs/api/java.base/java/util/Optional.html). Dans le développement actuel, nous avons véritablement introduit Optional, et c'est devenu un environnement où Stream et Optional peuvent être utilisés plus efficacement.

En dehors de cela, on me demande souvent "Puis-je écrire ceci dans Stream?" "Je veux écrire dans Stream ici ..." ... En regardant le code des autres, j'ai pensé que Stream pourrait être écrit plus magnifiquement ...

Dans tous les cas, je veux que vous écriviez dans Stream de manière plus agressive! (Pourquoi voulez-vous écrire dans Stream ici)

D'ailleurs, si vous pouvez lire la référence officielle sans hésitation, cet article peut ne pas être utile.

Remarque

Histoire principale

"⭐️" est attaché aux éléments les plus utilisés.

Hypothèse de la classe Widget 
class Widget {
    private Color color;
    
    private int weight;
    
    private String text;
    
    private List<Widget> childWeights = new ArrayList<>();
    
    public Widget(Color color, int weight) {
        this.color = color;
        this.weight = weight;
    }
    
    public Widget(Color color, int weight, String text) {
        this(color, weight);
        this.text = text;
    }
    
    public Color getColor() {
        return color;
    }
    
    public int getWeight() {
        return weight;
    }
    
    public Optional<String> getText() {
        return Optional.ofNullable(text);
    }
    
    public List<Widget> getChildWeights() {
        return childWeights;
    }
    
    public void setChildWeights(List<Widget> childWeights) {
       this.childWeights = childWeights;
    }
    
    public boolean isColorRed() {
        return color == RED;
    }
    
    public boolean isColorBlue() {
        return color == BLUE;
    }
    
    @Override
    public String toString() {
        return "Widget {color: " + color + ", weigth: " + weight + "}";
    }
    
    @Override
    public boolean equals(Object o) {
        Widget w = (Widget) o;
        return this.color == w.color && this.weight == w.weight;
    }
}

Génération de flux

⭐️ À partir de la liste / de l'ensemble / de la carte

Comment utiliser le n ° 1

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

//De la liste
List<Widget> list = List.of(a, b, c); // [a, b, c]
Stream<Widget> listToStream = list.stream(); // <a, b, c>
//À partir de l'ensemble
Set<Widget> set = Set.of(a, b, c); // {a, b, c}
Stream<Widget> setToStream = set.stream(); // <a, b, c>
//De la carte
Map<Long, Widget> map = Map.of(1L, a, 2L, b, 3L, c); // {1L : a, 2L : b, 3L : c}
Stream<Long> mapKeyToStream = map.keySet().stream(); // <1L, 2L, 3L>
Stream<Widget> mapValueToStream = map.values().stream(); // <a, b, c>
Stream<Entry<Long, Widget>> mapToStream = map.entrySet().stream(); // <{1L : a}, {2L : b}, {3L : c}>

Quand vous voulez mettre en parallèle depuis le début

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

//De la liste
List<Widget> list = List.of(a, b, c); // [a, b, c]
Stream<Widget> listToStream = list.parallelStream(); // <a, b, c>
//À partir de l'ensemble
Set<Widget> set = Set.of(a, b, c); // {a, b, c}
Stream<Widget> setToStream = set.parallelStream(); // <a, b, c>
//De la carte
Map<Long, Widget> map = Map.of(1L, a, 2L, b, 3L, c); // {1L : a, 2L : b, 3L : c}
Stream<Long> mapKeyToStream = map.keySet().parallelStream(); // <1L, 2L, 3L>
Stream<Widget> mapValueToStream = map.values().parallelStream(); // <a, b, c>
Stream<Entry<Long, Widget>> mapToStream = map.entrySet().parallelStream(); // <{1L : a}, {2L : b}, {3L : c}>

À partir du tableau

Widget[] arr = {a, b, c};
Stream<Widget> arrayToStream = Arrays.stream(arr); // <a, b, c>

De quelques valeurs

1 pièce

Stream<Long> stream1 = Stream.of(100L); // <100L>

//× Erreur
Stream<Long> stream2 = Stream.of(null); // <null> ?

2..N pièces

Stream<Long> stream1 = Stream.of(100L, 200L); // <100L, 200L>
Stream<String> stream2 = Stream.of("A", "B", "C", null); // <"A", "B", "C", null>

Stream<Long> stream3 = Stream.of(null, null); // <null, null>

0 .. 1 pièce

Stream<Long> stream1 = Stream.ofNullable(100L); // <100L>

Stream<Long> stream2 = Stream.ofNullable(null); // <>
Stream<Long> stream3 = Stream.empty(); // <>

À partir de plusieurs flux

⭐️ À partir de 2 flux

Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Stream<Widget> stream2 = Stream.of(x, y, z); // <x, y, z>
Stream<Widget> stream3 = Stream.concat(stream1, stream2); // <a, b, c, x, y, z>

3. Depuis N Streams

Je ne l'ai pas utilisé, mais je peux l'écrire comme ça en cas d'urgence

Stream<Widget> stream1 = Stream.of(a, b); // <a, b>
Stream<Widget> stream2 = Stream.of(c, d); // <c, d>
Stream<Widget> stream3 = Stream.of(e, f); // <e, f>
Stream<Widget> stream4 = Stream.of(g, h); // <g, h>
Stream<Stream<Widget>> stream5_1 = Stream.of(stream1, stream2, stream3, stream4); // <<a, b>, <c, d>, <e, f>, <g, h>>
Stream<Widget> stream5_2 = stream5_1.flatMap(UnaryOperator.identity()); // <a, b, c, d, e, f, g, h>

À partir d'une plage spécifique d'entiers (IntStream)

IntStream stream1To4 = IntStream.range(1, 5); // IntStream<1, 2, 3, 4>
IntStream stream1To5 = IntStream.rangeClosed(1, 5); // IntStream<1, 2, 3, 4, 5>

Fonctionnement intermédiaire

⭐️ Cartographie

Conversion 1: 1

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

// Widget -> Color
Stream<Widget> stream1_1 = Stream.of(a, b, c); // <a, b, c>
Stream<Color> stream1_2 = stream1_1.map(Widget::getColor); // <RED, RED, BLUE>

// Widget ->poids(int)
Stream<Widget> stream2_1 = Stream.of(a, b, c); // <a, b, c>
Stream<Integer> stream2_2 = stream2_1.map(Widget::getWeight); // <10, 15, 20>

// number -> number * 2
IntStream stream3_1 = IntStream.range(1, 5); // IntStream<1, 2, 3, 4>
IntStream stream3_2 = stream3_1.map(i -> i * 2); // IntStream<2, 4, 6, 8>

Conversion 1: 0..N

Widget a = new Widget(RED, 10);
Widget a_1 = new Widget(RED, 1);
Widget a_2 = new Widget(RED, 2);
Widget a_3 = new Widget(RED, 4);
a.setChildWeights(List.of(a_1, a_2, a_3));
Widget b = new Widget(RED, 15);
Widget b_1 = new Widget(RED, 8);
b.setChildWeights(List.of(b_1));
Widget c = new Widget(BLUE, 20);

// Widget ->Chaque widget enfant
Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Stream<List<Widget>> stream2 = stream1.map(Widget::getChildWeights); // <[a_1, a_2, a_3], [b_1], []>
Stream<Widget> stream3 = stream2.flatMap(Collection::stream); // <a_1, a_2, a_3, b_1>

Conversion 1: 0..1

Widget a = new Widget(RED, 10, "A");
Widget b = new Widget(RED, 15, "B");
Widget c = new Widget(BLUE, 20);

// Widget -> text(String)
Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Stream<Optional<String>> stream2 = stream1.map(Widget::getText); // <<"A">, <"B">, <>>
Stream<String> stream3 = stream2.flatMap(Optional::stream); // <"A", "B">

De Stream \ <T > à IntStream, etc.

Stream<Integer> stream1_1 = Stream.of(1, 2, 3, 4); // <1, 2, 3, 4>
IntStream stream1_2 = stream1_1.mapToInt(i -> i); // IntStream<1, 2, 3, 4>

De IntStream etc. vers Stream \ <Integer > etc.

IntStream stream1_1 = IntStream.range(1, 5); // IntStream<1, 2, 3, 4>
Stream<Integer> stream1_2 = stream1_1.boxed(); // <1, 2, 3, 4>

IntStream stream2_1 = IntStream.range(1, 5); // IntStream<1, 2, 3, 4>
Stream<String> stream2_2 = stream2_1.mapToObj(i -> String.valueOf(i)); // <"1", "2", "3", "4">

⭐️ Filtre

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);
Widget d = new Widget(GREEN, 25);

//Extraire les rouges
Stream<Widget> stream1_1 = Stream.of(a, b, c, d); // <a, b, c, d>
Stream<Widget> stream1_2 = stream1_1.filter(Widget::isColorRed); // <a, b>
//Extrayez ceux qui pèsent plus de 10
Stream<Widget> stream1_3 = Stream.of(a, b, c, d); // <a, b, c, d>
Stream<Widget> stream1_4 = stream1_3.filter(w -> w.getWeight() > 10); // <b, c, d>

//Extraire les non rouges(1)
Stream<Widget> stream2_1 = Stream.of(a, b, c, d); // <a, b, c, d>
Stream<Widget> stream2_2 = stream2_1.filter(w -> !w.isColorRed()); // <c, d>
//Extraire les non rouges(2)
Stream<Widget> stream2_3 = Stream.of(a, b, c, d); // <a, b, c, d>
Stream<Widget> stream2_4 = stream2_2.filter(Predicate.not(Widget::isColorRed)); // <c, d>

//Extraire les équivalents(1)
Stream<Widget> stream3_1 = Stream.of(a, b, c, d, null); // <a, b, c, d, null>
Stream<Widget> stream3_2= stream3_1.filter(w -> Objects.equals(w, new Widget(RED, 15))); // <b>
//Extraire les équivalents(2)
Stream<Widget> stream3_3 = Stream.of(a, b, c, d, null); // <a, b, c, d, null>
Stream<Widget> stream3_4= stream3_3.filter(Predicate.isEqual(new Widget(RED, 15))); // <b>

//Extraire les rouges ou bleus(1)
Stream<Widget> stream4_1 = Stream.of(a, b, c, d); // <a, b, c, d>
Stream<Widget> stream4_2 = stream4_1.filter(w -> w.isColorRed() || w.isColorBlue()); // <a, b, c>
//Extraire les rouges ou bleus(2)
Stream<Widget> stream4_3 = Stream.of(a, b, c, d); // <a, b, c, d>
Predicate<Widget> isColorRed = Widget::isColorRed; 
// Widget::Parce qu'il n'y a aucune garantie que isColorRed est un prédicat
// filter((Widget::isColorRed).or(Widget::isColorBlue))Je ne peux pas écrire
Stream<Widget> stream4_4 = stream4_2.filter(isColorRed.or(Widget::isColorBlue)); // <a, b, c>

Déduplication (distincte)

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);

Stream<Widget> stream1_1 = Stream.of(a, a, b, b, null, null); // <a, a, b, b, null, null>
Stream<Widget> stream1_2 = stream1_1.distinct(); // <a, b, null>

⭐️ Trier


Widget a = new Widget(RED, 10, "A");
Widget b = new Widget(RED, 15, "B");
Widget c = new Widget(BLUE, 20);
Widget d = new Widget(GREEN, 25;

//Trier par poids
Stream<Widget> stream1_1 = Stream.of(b, c, a); // <b, c, a>
Stream<Widget> stream1_2 = stream1_1.sorted(Comparator.comparing(Widget::getWeight)); // <a, b, c>

//Trier par poids(Ordre décroissant)
Stream<Widget> stream2_1 = Stream.of(b, c, a); // <b, c, a>
Stream<Widget> stream2_2 = stream2_1.sorted(Comparator.comparing(Widget::getWeight, Comparator.reverseOrder())); // <c, b, a>

//Trier par texte(Rendre nul d'abord)
Stream<Widget> stream3_1 = Stream.of(b, c, a); // <b, c, a>
Stream<Widget> stream3_2 = stream3_1.sorted(Comparator.comparing(w -> w.getText().orElse(null), Comparator.nullsFirst(Comparator.naturalOrder()))); <c, a, b>

//Premier tri:Est-ce rouge,Deuxième tri:poids
Stream<Widget> stream4_1 = Stream.of(b, c, a, d); // <b, c, a, d>
Stream<Widget> stream4_2 = stream4_1.sorted(Comparator.comparing(Widget::isColorRed).thenComparing(Widget::getWeight)); // <c, d, a, b>

N premier

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5); // <1, 2, 3, 4, 5>
Stream<Integer> stream2 = stream1.limit(3); // <1, 2, 3>

Autre que le premier N

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5); // <1, 2, 3, 4, 5>
Stream<Integer> stream2 = stream1.skip(2); // <3, 4, 5>

Opération de terminaison

⭐️ Créer une liste

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream = Stream.of(a, b, c); // <a, b, c>
List<Widget> list = stream.collect(Collectors.toList()); // [a, b, c]

Créer un ensemble

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream = Stream.of(a, b, c); // <a, b, c>
Set<Widget> set = stream.collect(Collectors.toSet()); // {a, b, c}

⭐️ Créer une carte

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Map<Integer, Color> map1 = stream.collect(Collectors.toMap(Widget::getWeight, Widget::getColor)); // {10: RED, 15: RED, 20: BLUE}

Stream<Widget> stream2_1 = Stream.of(a, b, c); // <a, b, c>
Map<Color, Widget> map2_1 = stream.collect(Collectors.toMap(Widget::getColor, UnaryOperator.identity(), (w1, w2) -> w1)); // {RED: a, BLUE: c}
Stream<Widget> stream2_2 = Stream.of(a, b, c); // <a, b, c>
Map<Color, Widget> map2_2 = stream.collect(Collectors.toMap(Widget::getColor, UnaryOperator.identity(), (w1, w2) -> w2)); // {RED: b, BLUE: c}
//× Erreur(En cas de conflit de clé, il est nécessaire de spécifier s'il faut prioriser le premier ou le second)
Stream<Widget> stream2_3 = Stream.of(a, b, c); // <a, b, c>
Map<Color, Widget> map2_3 = stream.collect(Collectors.toMap(Widget::getColor, UnaryOperator.identity())); 

Stream<Widget> stream3 = Stream.of(a, b, c); // <a, b, c>
Map<Color, List<Widget>> map3 = stream3.collect(Collectors.groupingBy(Widget::getColor)); // {RED: [a, b], BLUE: [c]}

⭐️ Traitement itératif (pour chacun)

Stream<Integer> stream = Stream.of(1, 2, 3); // <1, 2, 3>
stream.forEach(System.out::println);
//Sortie standard:
// 1
// 2
// 3

Obtenez le nombre d'éléments

Stream<Integer> stream = Stream.of(1, 2, 3); // <1, 2, 3>
long cnt = stream.count(); // 3L

⭐️ Combiner des chaînes

Stream<Widget> stream1 = Stream.of("A", "B", "C"); // <"A", "B", "C">
String str1 = stream1.collect(Collectors.joining()); // "ABC"

Stream<Widget> stream2 = Stream.of("A", "B", "C"); // <"A", "B", "C">
String str2 = stream2.collect(Collectors.joining(", ")); // "A, B, C"

Stream<Widget> stream3 = Stream.of("A", "B", "C"); // <"A", "B", "C">
String str3 = stream3.collect(Collectors.joining(", ", "[", "]")); // "[A, B, C]"

Obtenez la somme des nombres

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream1_1 = Stream.of(a, b, c); // <a, b, c>
IntStream stream1_2 = stream1_1.mapToInt(Widget::getWeight); // <10, 15, 20>
int sum1 = stream1_2.sum(); // 45

Stream<Widget> stream2_1 = Stream.of(a, b, c); // <a, b, c>
int sum2 = stream2.collect(Collectors.summingInt(Widget::getWeight)); // 45

⭐️ Obtenez le maximum

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Optional<Widget> widget = stream1.max(Comparator.comparing(Widget::getWeight)); // <c>

Stream<Widget> stream2_1 = Stream.of(a, b, c); // <a, b, c>
IntStream stream2_2 = stream2_1.mapToInt(Widget::getWeight); // <10, 15, 20>
OptionalInt max = stream2_2.max(); // <20>

⭐️ Obtenez la valeur minimale

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
Optional<Widget> widget = stream1.min(Comparator.comparing(Widget::getWeight)); // <a>

Stream<Widget> stream2_1 = Stream.of(a, b, c); // <a, b, c>
IntStream stream2_2 = stream2_1.mapToInt(Widget::getWeight); // <10, 15, 20>
OptionalInt min = stream2_2.min(); // <10>

⭐️ Obtenez le premier élément

Stream<Integer> stream = Stream.of(1, 2, 3); // <1, 2, 3>
Optional<Integer> n = stream.findFirst() // <1>

⭐️ Obtenez n'importe quel élément

Stream<Integer> stream = Stream.of(1, 2, 3); // <1, 2, 3>
Optional<Integer> n = stream.findAny() // <1>

⭐️ Renvoie une valeur booléenne

Un ou plusieurs éléments répondent aux critères

Widget a = new Widget(RED, 10);
Widget b = new Widget(RED, 15);
Widget c = new Widget(BLUE, 20);

Stream<Widget> stream1 = Stream.of(a, b, c); // <a, b, c>
boolean bool1 = stream1.anyMatch(Widget::isColorRed); // true

Stream<Widget> stream2 = Stream.of(c); // <c>
boolean bool2 = stream2.anyMatch(Widget::isColorRed); // false

Stream<Widget> stream3 = Stream.of(); // <>
boolean bool3 = stream3.anyMatch(Widget::isColorRed); // false

Tous les éléments remplissent les conditions

Notez le comportement lorsque Stream est vide

Stream<Widget> stream1 = Stream.of(a, b); // <a, b>
boolean bool1 = stream1.allMatch(Widget::isColorRed); // true

Stream<Widget> stream2 = Stream.of(b, c); // <b, c>
boolean bool2 = stream2.allMatch(Widget::isColorRed); // false

Stream<Widget> stream3 = Stream.of(); // <>
boolean bool3 = stream3.allMatch(Widget::isColorRed); // true

Tous les éléments ne remplissent pas les conditions

Notez le comportement lorsque Stream est vide

Stream<Widget> stream1 = Stream.of(c); // <c>
boolean bool1 = stream1.noneMatch(Widget::isColorRed); // true

Stream<Widget> stream2 = Stream.of(b, c); // <a, b, c>
boolean bool2 = stream2.noneMatch(Widget::isColorRed); // false

Stream<Widget> stream3 = Stream.of(); // <>
boolean bool3 = stream3.noneMatch(Widget::isColorRed); // true

Recommended Posts

[Java11] Résumé de l'utilisation du flux -Basics-
Résumé approximatif du flux Java8
[Java11] Résumé du flux -Avantages du flux-
Résumé des bases du langage Java
Les bases de Java
Les bases de Java
Les bases de Java
Résumé des connaissances Java
Résumé des génériques Java
Essayez Java 8 Stream
bases de la programmation Java
API Java Stream
Principes de base de Java JAR
Notions de base orientées objet (Java)
Résumé du document Java 8
Étudier Java 8 (Stream)
Principes de base du traitement parallèle Java
Résumé du document Java 11
Terminaison du flux Java
[Java] Traitement de flux
Principes de base de l'API Stream
Java 9 Facultatif :: stream
Java n ° 3 pour l'utilisation de la mémoire de flux utile pour les entreprises
Résumé des nouvelles fonctionnalités de Java 12
[Java] Remarque sur les collecteurs de flux
[Résumé] Par exemple, préparation de l'environnement Java
3ème résumé efficace de Java
Résumé des nouvelles fonctionnalités de Java 13
[Java] Génération de flux API-Stream
[Java] API / carte de flux
Comment utiliser les variables Java
Bases de la programmation Java Practice-array
Java statique [Résumé personnel]
Principes de base du réseau Java (communication)
Résumé des threads sûrs ~ Java ~
À propos de l'opération de réduction du flux Java8
Résumé de la spécialisation des primitives Java
Résumé du lien de développement Java
Résumé personnel sur Java
Résumé des nouvelles fonctionnalités de Java 10
Muscle Java Basics Jour 1
Résumé des nouvelles fonctionnalités de Java 14
Résumé du support Java 2018
Résumé du modèle de conception Java
Résumé du mot réservé Java
Qu'est-ce que l'assertion Java? Résumé.
[Java] Utilisation de Mirage-Basic de SQL
Principes de base de l'utilisation des caractères (Java)
Aide-mémoire de l'API Java Stream
[Java] Résumé des expressions régulières
[Java] Résumé des opérateurs (opérateur)
Résumé orienté objet par les débutants (Java)
Instruction pratique de base de la programmation Java
Java Stream ne peut pas être réutilisé.
Astuces Java - Résumé de l'exécution de Spring
Résumé de la classe Java Math
Premiers pas avec les bases de Java
Bases du développement Java ~ Exercice (tableau) ~
[Java] Introduction à l'API Stream