[Java] Stream API-Stream-Generierung

Was ist die Steam-API?

• ** Bibliothek, die iterative Verarbeitung unterstützt **
• Extrahieren Sie Elemente aus einer Reihe von Daten (Datenquelle) wie Sammlungen, Arrays und Fals und übergeben Sie sie an den Prozessablauf (Stream).

Grundlagen der Stream-API

• ** Stream-Generierung aus Datenquelle **
• ** Zwischenverarbeitung ** (Extraktion, Verarbeitung usw.)
• Der Rückgabewert ist "Stream "
• ** Kündigungsverarbeitung ** (Ausgabe, Aggregation usw.)
• Eine Reihe von Streams wird zum Zeitpunkt der Beendigung ausgeführt (verzögerte Verarbeitung).
• Die Zwischen- / Beendigungsverarbeitung kann sich auf die Standardbibliothek beziehen, die dem Typ entspricht.
• ** Methodenkette **: Die Zwischen- / Beendigungsverarbeitung kann aus der Stream-Generierung mit dem Operator . verkettet werden

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

public class StreamBasic {

//Datenquellenvorbereitung
  public static void main(String[] args) {
    var list = new ArrayList<String>(Arrays.asList("ant", "elephant", "hamster"));

/*Verarbeitung per Stream
Stream-Generierung aus einer vorbereiteten Liste
ArrayList<String>Weil es auf basiert
Die Stream-Methode ist auch Stream<String>Gibt ein Objekt zurück
*/
    list.
      stream().
      /*Zwischenverarbeitung
Extrahieren Sie 3 oder mehr Zeichen mit der Filtermethode und konvertieren Sie sie mit der Karte in Großbuchstaben
Der Rückgabewert ist Stream<T>
      */
      filter(s -> s.length() > 3).
      map(String::toUpperCase).
      /*Beendigung
Systemieren Sie den von der forEach-Methode angegebenen Wert.out
      */
      forEach(System.out::println);//ELEPHANT HAMSTER
  }
}

Stream-Generierung

** Stream-Generierung aus Sammlungen und Arrays **

• Listen, Arrays und Karteninhalte können durch Stream-Verarbeitung ausgegeben werden

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

public class StreamBasic2 {

//aufführen
  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("---------------");

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

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

• ** parallelStream ** Parallele Version der Stream-Methode
• Wenn es sich um eine Sammlung von Listenzuordnungen handelt, ist eine parallele Verarbeitung möglich, wenn der Stream in parallelStream geändert wird.
  • list.parallelStream().forEach(System.out::println)

** Stream-Generierung aus Argument / Lambda-Ausdruck **

• Factory-Methode zur Stream-Generierung

** der Methode **

• ** Konvertiere das angegebene Argument variabler Länge in einen Stream **

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

** Methode generieren **

• ** Stream-Generierung mit dem angegebenen Rückgabewert des Lambda-Ausdrucks **
• Beispiel: Generieren und streamen Sie Zufallszahlen von 1 bis 100
• Unendliche Stream-Generierung, daher bei der Zwischen- / Terminierungsverarbeitung explizit unterbrochen
• Im folgenden Beispiel verarbeitet limit (10) nur die ersten 10 Fälle.
• Random.ints Methode beim Generieren eines zufälligen Streams in der App

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

** itaterate Methode **

• ** Stream-Generierung mit angegebenem Anfangswert und Lambda-Ausdruck **
• Der Anfangswert wird zuerst übergeben, und das vorherige Ergebnis wird danach übergeben.
• Im folgenden Beispiel wird 1 als Anfangswert festgelegt und ein verdoppelter Wert generiert.

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

** Builder-Methode **

• Stream.Builder-Objekt für die Stream-Assembly Aufrichtigkeit

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

** Concat-Methode **

• ** Kombinieren Sie zur Vereinfachung mehrere Streams zu einem Stream **

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

** Generiere einen Basis-Stream **

• Spezialisiert auf Grundtypen ** IntStream / LongStream / DoubleStream **
• ** der Factory-Methode / generate / iterate / builder ** kann verwendet werden
• IntStream / LongStream kann die ** Bereichsmethode ** verwenden

//Obergrenze Ah Nicht im Stream enthalten
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
  }
}

• Wenn Sie die Obergrenze einschließen möchten, ** rangeClosed-Methode **

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