Stream-Beendigung

Geben Sie schließlich die durch die Stream-Verarbeitung verarbeiteten / gefilterten Werte aus oder aggregieren Sie sie
** Streams werden zusammen mit der Terminierungsverarbeitung als Trigger verarbeitet **
Kündigungsbearbeitung ** kann nicht weggelassen werden **
Vgl.: Zwischenverarbeitung kann weggelassen werden
Stream kann nach Beendigung nicht wiederverwendet werden (IllegalStateException)

Elemente nacheinander verarbeiten

** für jede Methode **
Sie können die Referenz der System.out :: println-Methode unverändert oder als Lambda-Ausdruck übergeben.

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));
  }
}

forEach Methode ** garantiert keine Ordnung in parallelen Streams! ** ** **
→ Verwenden Sie die ** forEachOrdered-Methode **, um die Bestellung beizubehalten!

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 
    
    /*Wenn Sie die Bestellung behalten möchten
    .forEachOrdered(v -> System.out.println(v)); 
    Munchkin Siamese Persian Tama
    */
  }
}

Holen Sie sich den ersten Wert

** findFirst Methode **
Der Rückgabewert ist ** Optionaler Typ **, da der Stream möglicherweise von stammt

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();
      //Wenn die orElse-Methode null ist"-"Ersetzen mit
      System.out.println(str.orElse("－")); //Siamese
  }
}

** Die findAny-Methode ** gibt das erste * erhaltene Ergebnis in einem parallelen Stream ** zurück, sodass sich das Ergebnis ändern kann.

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
  }
}

Stellen Sie fest, ob der Wert bestimmte Bedingungen erfüllt

** anyMatch / allMatch / noneMatch-Methode **

//Überprüfen Sie, ob alle Werte in der Liste 0 oder mehr sind
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
  }
}

In Array / Sammlung konvertieren

** toArray-Methode **
Stream-Verarbeitungsergebnis als String-Array abrufen

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
  }
}

** Mit Sammlungsmethode in Sammlung konvertieren **
Konvertieren Sie die Stream-Verarbeitungsergebnisse in eine Liste
** toList **: In Liste konvertieren
** toSet **: In Set konvertieren
** toMap **: In Karte konvertieren
** toCollection **: Konvertierung in eine allgemeine Sammlung

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);
  }
}

** toMap-Methode **
Legen Sie das Zusammenführungsargument fest, wenn die Möglichkeit einer Duplizierung besteht (IllegalStateException).

//Benennen Sie das Personenobjektarray:In das Kartenformat der E-Mail-Adresse konvertieren
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(
          //Der Argumentschlüssel repräsentiert den Schlüssel der Karte
          Person::getName,
          //Der Argumentwert repräsentiert den Schlüssel der Karte
          Person::getEmail,
          //Wenn die Möglichkeit einer Vervielfältigung besteht
          (s, a) -> s + "/" + a
          //Wert beim Duplizieren überschreiben
          // (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;
  }
}

Finden Sie das Maximum und das Minimum

** min.max Methode **
Komparatortyp als Argument
Nach natürlicher Reihenfolge sortieren
Da der Rückgabewert ein optionaler Typ ist, ** oder Else-Methode ** zum Abrufen von Werten

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
  }
}

Finden Sie die Anzahl der Elemente

** Zählmethode **

//Finden Sie die Anzahl der Zeichenfolgen, die größer als die Zeichenfolgenlänge 3 sind.
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
    );
  }
}

Finden Sie den Gesamt- / Durchschnittswert

** Summen- / Durchschnittsmethode **
Nur für Basis-Streams verfügbar
Der Rückgabewert der Durchschnittsmethode ist ** OptionalDouble-Typ **
Mit der orElse-Methode extrahieren

//Int Array Summe, Durchschnitt
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
  }
}

Kombinieren Sie Stream-Werte zu einem

** Die Ermäßigung **
Die Max / Min / Count-Methode wurde ebenfalls reduziert
** Methode reduzieren ** zur allgemeinen Reduzierung

Mit einem Argument:

Argumente, die von der Reduktionsmethode empfangen wurden (Lambda-Ausdruck)
** Variable zum Speichern des Operationsergebnisses ** (Ergebnis)
** Variablen zum Empfang einzelner Elemente ** (str)

//Gruppieren Sie Zeichenfolgenströme, die durch Kommas getrennt sind
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
    );
  }
}

Mit 2 Argumenten:

Sie können den Anfangswert erhalten
Das Ergebnis ist nicht null, also nicht optional
Wert kann erhalten werden, ohne orElse zu durchlaufen
In parallelen Streams ändert sich das Ergebnis, da der Anfangswert um den verteilten Betrag auf den Lambda-Ausdruck angewendet wird.
Aufgrund der Parallelisierung besteht die Möglichkeit, dass Anfangswerte dupliziert werden

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
  }
}

Mit 3 Argumenten:

Wird verwendet, wenn der Stream-Elementtyp und der ** Endergebnis-Typ unterschiedlich sind **
Wenn Sie einzelne Elemente mit reduzieren erhalten, sind das Operationsergebnis (Ergebnis) und die Variable (Wert) jedes Elements ** verschiedene Typen sind OK **
Fügen Sie dem Zeichenergebnis (Integer) den in einen numerischen Wert konvertierten Zeichenfolgenwert hinzu.

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,
          //Holen Sie sich einzelne Elemente
          //Das Operationsergebnis wird im Ergebnis gespeichert und der Wert empfängt jedes Element.
          (result, value) -> {
            return result + Integer.parseInt(value); //Konvertieren Sie den Zeichenfolgenwert in eine Zahl
          },
          //Fassen Sie die verteilten Ergebnisse zusammen(Nur paralleler Stream)
          (result1, result2) -> {
            return result1 + result2; //1452
          }
      )
    );
  }
}

Sammle Stream-Elemente in einer Sammlung (1)

** Sammelmethode **
** Variablenreduzierung **: Speichert und gibt Werte in einem variablen Container (Container) wie einer Sammlung oder einem StringBuilder zurück
cf: reduziert kombiniert Elemente in einem Stream zu einem ** einzelnen Typ wie int / String **

//Sortiert einen bestimmten String-Stream und konvertiert ihn in eine 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(
          //Erstellung eines Containers, der den Wert im ersten Wert der Reduzierung um die Anzahl der Ausdrücke speichert
          ArrayList<String>::new,
          //Argumente sind Container, einzelne Elemente
          (list, str) -> list.add(str),
          //Für parallele Streams
          (list1, list2) -> list1.addAll(list2)
        )
    );
  }
}

Sammle Stream-Elemente in einer Sammlung (2)

** Sammelmethode hat Überladung **
Kann mit der statischen Methode Collector.of generiert werden
Collector-Attribut
** CONCURRENT **: Der Akku kann in mehreren Threads ausgeführt werden
** UNORDERED **: Garantieren Sie nicht die Reihenfolge der Elemente
** IDENTITY_FINISH **: Finisher kann weggelassen werden

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
          )
        )
    );
  }
}

Standardkollektor

Die Collectors-Klasse verfügt über eine Factory-Methode, mit der ein Collector erstellt wird, der mit der Collector-Methode verwendet werden kann.
** Implementieren Sie einfach die typische Redaktionsverarbeitung! ** ** **
ToList- und toMap-Methoden sind ebenfalls in der Factory-Methode enthalten

Verbindungsmethode

Collecter-Generierung von String-Joins

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>
      );
  }
}

groupingBy Methode

Kollektorgenerierung zum Gruppieren von Werten nach angegebenem Schlüssel

//Kategorisieren Sie Zeichenfolgen nach Länge
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(
          //Empfangen Sie den Elementtyp mit dem Argument str und generieren Sie den Gruppierungsschlüssel
          //Nach Zeichenfolge gruppieren
            Collectors.groupingBy(str -> str.length()
          )) //{4=[Tama], 7=[Persian, Siamese], 8=[Munchkin], 13=[Scottish Fold]}
      );
  }
}

** Verarbeite die gruppierten Ergebnisse in einem anderen Kollektor **
Geben Sie ein Argument für den Beitritt an

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}
          ))
      );
  }
}

partitioningBy Methode

** Einfache Gruppierung in wahr / falsch **

//Teilen Sie durch, ob die Zeichenfolge 7 Zeichen oder weniger oder lang ist
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]}
        )
      );
  }
}

collectAndThen Methode

Ausführung der Beendigungsverarbeitung nach der Ausführung des Kollektors
Verketten von Kollektor und Nachbearbeitung

//Listen Sie Streams mit der toList-Methode auf
//Collections::Mit unmodifizierbarer Liste in schreibgeschützt konvertieren

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
            )
          )
      );
  }
}

IntSummaryStatistics Klasse

Holen Sie sich grundlegende numerische Statistiken
Der Rückgabewert der Methode collect ist das Objekt (Int) SummaryStatistics
Holen Sie sich Statistiken mit der Getter-Methode
** getAverage () **: Durchschnittswert (0, wenn kein Wert vorhanden ist)
** getCount () **: Anzahl der Elemente
** getMax () **: Maximum
** getMin () **: Minimum
** getSum () **: Gesamt (0, wenn kein Wert)

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(
     //Übergeben Sie im Konstruktor einen Verweis auf parseInt sod, accept, combinDB
        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 - Stream-Beendigungsverarbeitung

Stream-Beendigung

Elemente nacheinander verarbeiten

Holen Sie sich den ersten Wert

Stellen Sie fest, ob der Wert bestimmte Bedingungen erfüllt

In Array / Sammlung konvertieren

Finden Sie das Maximum und das Minimum

Finden Sie die Anzahl der Elemente

Finden Sie den Gesamt- / Durchschnittswert

Kombinieren Sie Stream-Werte zu einem

Mit einem Argument:

Mit 2 Argumenten:

Mit 3 Argumenten:

Sammle Stream-Elemente in einer Sammlung (1)

Sammle Stream-Elemente in einer Sammlung (2)

Standardkollektor

** Verbindungsmethode **

** groupingBy Methode **

** partitioningBy Methode **

** collectAndThen Methode **

** IntSummaryStatistics Klasse **

Verbindungsmethode

groupingBy Methode

partitioningBy Methode

collectAndThen Methode

IntSummaryStatistics Klasse