Detaillierte Erläuterung der Stream-API in Java 8

Lassen Sie uns zunächst ein Beispiel geben, um die Vorteile der Java 8 Stream API zu zeigen.

Angenommen, wir haben folgende Aufgaben:

Angesichts einer Liste von Zeichenfolgen müssen wir Folgendes tun:

1. Filtern Sie alle Zeichenfolgen heraus, die mit „A“ beginnen.

2. Wandeln Sie diese Zeichenfolgen in Großbuchstaben um.

3. Sortieren Sie diese Zeichenfolgen nach Länge.

4. Abschließend werden diese Zeichenfolgen zu einer einzigen durch Kommas getrennten Zeichenfolge verkettet.

   Java 7 und frühere Implementierungen:

   In Java 7 erfordert die Implementierung dieser Funktion eine mehrstufige Verarbeitung, die Schleifen, bedingte Beurteilungen, Sortierung und String-Spleißen umfasst.

   List<String> inputList = Arrays.asList("Apple", "An", "Banana", "Avocado", "Apricot", "Blueberry");
   List<String> filteredList = new ArrayList<String>();
   for (String s : inputList) {
         
         
       if (s.startsWith("A")) {
         
         
           filteredList.add(s.toUpperCase());
       }
   }
   Collections.sort(filteredList, new Comparator<String>() {
         
         
       public int compare(String s1, String s2) {
         
         
           return Integer.compare(s1.length(), s2.length());
       }
   });
   
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < filteredList.size(); i++) {
         
         
       sb.append(filteredList.get(i));
       if (i < filteredList.size() - 1) {
         
         
           sb.append(", ");
       }
   }
   String result = sb.toString();
   

   Java 8-Implementierung mithilfe von Streams:

   Die gleiche Aufgabe kann mit der Streams-API von Java 8 auf einfachere und intuitivere Weise gelöst werden:

   List<String> inputList = Arrays.asList("Apple", "An", "Banana", "Avocado", "Apricot", "Blueberry");
   String result = inputList.stream()
                            .filter(s -> s.startsWith("A"))
                            .map(String::toUpperCase)
                            .sorted(Comparator.comparingInt(String::length))
                            .collect(Collectors.joining(", "));
   

   Verglichen

   Bei der Implementierung von Java 7 müssen wir explizit Schleifen, bedingte Beurteilungen, Sortierungen und Zeichenfolgenverkettungen durchführen, was nicht nur den Code länger macht, sondern auch die Logik auf einen Blick schwieriger zu erkennen macht. Bei der Implementierung von Java 8 sind alle diese Vorgänge in einen Kettenaufruf im Pipeline-Stil integriert, und jeder Schritt ist klar und intuitiv. filterDie Verwendung von Methoden wie , und erleichtert das Lesen und Warten des Codes map. Insbesondere wird der Code durch die direkte Verkettung der gefilterten und konvertierten String-Listen zu einem String erheblich vereinfacht. Dieses Beispiel zeigt deutlich die leistungsstarken Funktionen der Java 8-Stream-API, insbesondere bei komplexen Erfassungsvorgängen liegen ihre Vorteile auf der Hand.sortedcollectCollectors.joining

1. Was ist Stream?

Stream von Java 8 stellt eine Erweiterung der Funktionalität von Sammlungsobjekten dar. Der Schwerpunkt liegt auf der Durchführung verschiedener sehr praktischer und effizienter Aggregationsoperationen (Aggregatoperationen) oder Massendatenoperationen (Massendatenoperationen) für Sammlungsobjekte. Die Stream-API kann die Produktivität von Java-Programmierern erheblich steigern und ermöglicht es Programmierern, effizienten, sauberen und prägnanten Code zu schreiben.

Die Stream-API von Java 8 bietet eine effiziente, deklarative Möglichkeit, Sammlungen zu verarbeiten. Mit der Stream-API können Sie komplexe Abfragen, Filter, Konvertierungen, Sortierungen und andere Vorgänge für Sammlungen durchführen, ohne sich um die zugrunde liegenden Implementierungsdetails kümmern zu müssen.

2. Warum Streams verwenden?

Mit Java 8 wurden Streams eingeführt, um die Verarbeitung von Erfassungsdaten komfortabler und flexibler zu gestalten. Streams bieten eine neue Abstraktion, die es Entwicklern ermöglicht, Daten auf deklarative Weise zu bearbeiten, ohne explizit Iteratoren verwenden oder große Mengen an Schleifencode schreiben zu müssen.

3. Was passiert, wenn kein Durchfluss erfolgt?

Während die gleiche Funktionalität immer noch ohne die Verwendung von Streams erreicht werden kann, kann die Verwendung von Streams für saubereren, effizienteren und einfacher zu verwaltenden Code sorgen, insbesondere bei der Verarbeitung komplexer Datenoperationen. Die Streams-API ist eine wichtige Funktion in Java 8, die die Fähigkeit der Java-Sprache, Sammlungen zu verarbeiten, erheblich verbessert.

4. Was sind die Merkmale von Stream?

• Keine Datenstruktur : Sie speichert keine Daten, sondern wird zum Bearbeiten von Daten in Datenquellen (z. B. Sammlungen, Arrays usw.) verwendet.
• Ändert das Originalobjekt nicht : Es verändert das Originalobjekt nicht. Stattdessen gibt es einen neuen Stream zurück, der das Ergebnis enthält.
• Verzögerte Ausführung : Operationen werden verzögert ausgeführt, d. h. sie warten, bis die Ergebnisse benötigt werden.
• Verbrauchbarkeit : Der Stream kann nur einmal konsumiert werden. Es wird ungültig, sobald es durchlaufen wird.

5. Häufig verwendete Streaming-Methoden?

Stream-Operationen werden in zwei Typen unterteilt: Zwischenoperationen und Terminaloperationen.

Zwischenoperationen

• Karte: Elemente in andere Formen umwandeln oder Informationen extrahieren.

  stream.map(String::toUpperCase);
  

• Filter: Bestimmte Elemente ausschließen.

  stream.filter(e -> e.length() > 2);
  

• sortiert: Stellt sicher, dass der Stream nach bestimmten Kriterien sortiert wird.

  stream.sorted(Comparator.comparingInt(String::length));
  

• limit: Reduzieren Sie die Größe des Streams.

  stream.limit(5);
  

• Distinct (Deduplizierung): Entfernen Sie doppelte Elemente durch hashCode() und equal() der vom Stream generierten Elemente.

  stream.distinct();
  

Terminalbetrieb

• forEach (iterate): Iteriert alle Daten im Stream.

  stream.forEach(System.out::println);
  

• sammeln: Konvertieren Sie den Stream in andere Formen.

  List<String> list = stream.collect(Collectors.toList());
  

• Reduzieren (Reduzieren): Kombinieren Sie wiederholt alle Elemente im Stream, um einen Wert zu erhalten.

  Integer sum = numbers.stream().reduce(0, Integer::sum);
  

• anyMatch, allMatch, noneMatch (match): Prüft, ob ein oder mehrere Elemente im Stream mit dem angegebenen Prädikat übereinstimmen.

  boolean anyMatch = stream.anyMatch(e -> e.startsWith("A"));
  

• count: Gibt die Anzahl der Elemente im Stream zurück.

  long count = stream.count();
  

• findFirst, findAny (find): Gibt das erste oder ein beliebiges Element im Stream zurück.

  Optional<String> first = stream.findFirst();
  

6. Beispiel

List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println); // C1, C2

In diesem Beispiel stream()wird ein Stream erstellt, filter()eine Methode filtert Zeichenfolgen heraus, die nicht mit „c“ beginnen, map()eine Methode wandelt jede Zeichenfolge in Großbuchstaben um, sorted()eine Methode sortiert die Zeichenfolgen und schließlich forEach()gibt eine Methode jedes Element aus.