[Java] Stream API - Stream Zwischenverarbeitung

Zwischenverarbeitung streamen

• Verarbeiten und filtern Sie die durch den Stream fließenden Werte
• Es wird ausgeführt **, wenn der Beendigungsprozess aufgerufen wird **

Filtern Sie Werte nach festgelegten Bedingungen

• ** Filtermethode **

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)
*/
  }
}

Verarbeiten Sie den angegebenen Wert

• ** Kartenmethode **
• Konvertieren Sie die Zeichenfolgenliste in die Zeichenfolgenlängenliste und geben Sie sie aus
• Unmittelbar nach der Generierung wird es zu "String " und nach dem Durchlaufen der Map-Methode zu "String <Ganzzahl".

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

• Generiere einen Stream vom Basistyp ** mapToInt / mapToLong / mapToDouble-Methode **
• "IntStream" wird anstelle von "String " generiert
• Reduzierte Boxbelastung

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

Verarbeiten Sie ein bestimmtes Element

• ** flatMap / flatMapToXX-Methode **
• Der Unterschied zur Karte besteht darin, dass das Konvertierungsergebnis ** als Stream-Typ ** zurückgegeben wird.
• Von einzelnen Elementen zurückgegebene Streams werden schließlich kombiniert und zurückgegeben

//Konvertieren Sie eine zweidimensionale Array-Liste in ein eindimensionales Array
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {

    var list = new String[][] {
      { "neko", "nekko", "nekkko" },
      { "inu", "innu" },
      { "tori", "torri" }
    };
    //Übergeben Sie ein verschachteltes Array mit flatMap und Arrays.Stream mit Stream-Methode
    //Durch Verbinden mit flatMap zu einem eindimensionalen Array reduzieren
    Arrays.stream(list)
      .flatMap(v -> Arrays.stream(v))
      .forEach(System.out::println);
     // neko nekko nekkko inu innu tori torri
    }
}

• Es ist auch möglich, Werte durch Verschachteln während der Stream-Verarbeitung zu verarbeiten **

//Extrahieren Sie das Akronym, wenn Sie ein zweidimensionales Array reduzieren
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
    }
}

Elemente sortieren

• ** sortierte Methode **
• Nach natürlicher Reihenfolge sortieren

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

• Wenn Sie Regeln festlegen möchten, ** setzen Sie mit Lambda-Ausdruck **

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

    /*Wörterbuch in umgekehrter Reihenfolge in der Komparatorschnittstelle
     Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
     .sorted(Comparator.reverseOrder())
     .forEach(System.out::println);
    */
  }
}

Extrahieren Sie das m-te Element

• ** Methode zum Überspringen / Begrenzen **
• ** Methode überspringen **: Bis zum m-ten Element abschneiden
• ** Grenzwertmethode **: Schneidet das n + 1-te und nachfolgende Elemente ab

//Verwenden Sie Überspringen, um 4 Elemente zu überspringen, und begrenzen Sie, um 10 Elemente daraus zu extrahieren.
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
  }
}

Entfernen Sie die Werte von Anfang an, während Sie die Bedingungen erfüllen

• ** dropWhile Methode **
• Überspringen Sie Werte, die dem bedingten Ausdruck entsprechen
• Entfernen Sie negative Zahlen vom Anfang des Streams
• Bis zum letzten ** Da es sich von Anfang an um einen kontinuierlichen Wert handelt, werden negative Zahlen in der Mitte nicht entfernt **
• → In der Mitte mit Filter entfernen

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

Extrahieren Sie nur die Werte, die die Bedingungen von Anfang an erfüllen

• ** takeWhile Methode **
• Verarbeiten Sie nur diejenigen, die vom Beginn des Streams an negativ sind
• Bis zum letzten ** Es ist der Wert, der von Anfang an stetig ist **

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

Überprüfen Sie den mittleren Status des Streams

• ** Peek-Methode **
• In der Mitte kann eine beliebige Verarbeitung eingefügt werden
• Peek-Methode ** hat keinen Einfluss auf den Stream **

//Stream-Inhalt vor und nach dem Sortieren ausgeben
import java.util.stream.Stream;
public class StreamPeek {
  public static void main(String[] args) {
    Stream.of("Fisch", "Schmutz", "Echo", "Kinmokusei")
      .peek(System.out::println)
      .sorted()
      .forEach(System.out::println);
  }
}

Entfernen Sie doppelte Werte

• ** unterschiedliche Methode **
• Entfernen Sie doppelte Werte im Stream
• Kann nicht mit einem bestimmten Feld einer Klasse als Schlüssel dedupliziert werden
• → Verwenden Sie die Filtermethode

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

• Suchen Sie nach Duplikaten, indem Sie das Namensfeld als Schlüssel in der Person-Klasse verwenden

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)
      )
      //Fügen Sie HashSet in der Filtermethode einen Wert hinzu
      //HashSet.Die Methode add gibt false zurück, wenn der Wert nicht hinzugefügt werden konnte (duplizieren).

      .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 Jahre alt)", this.name, this.age);
  }
}

Grundlegende Stream-Konvertierung

• ** Typkonvertierung mit asLongStream / asDoubleStream / LongStream **

//Konvertierung von IntStream zu 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
  }
}

Gegenseitige Konvertierung zwischen Streams vom Basistyp und Referenztyp

• Vom Basistyp zum Referenztyp: ** Boxed-Methode **
• Referenztyp zum Basistyp: ** mapToObj-Methode **

//IntStream zum Streamen<Integer>Umstellung auf
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>In IntStream konvertieren
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
    }
}