Sie sind also hier, um etwas über Bäche in Java zu erfahren, aber nicht über die Art von Bächen, in denen Menschen angeln gehen, oder über Wasserflüsse. Die Rede ist von Datenströmen, einer leistungsstarken Funktion, die in Java 8 eingeführt wurde und die Arbeit mit Daten erheblich vereinfacht. Machen Sie sich keine Sorgen, egal, ob Sie ganz neu dabei sind oder es ausprobiert haben, es aber nicht ganz knacken konnten. Ich begleite Sie durch die gesamte Reise in einfacher, leicht verständlicher Sprache.

Bereit? Tauchen wir ein in Java Streams!

Was ist ein Stream in Java?

Ein Stream ist eine Möglichkeit, Daten in einer Sequenz zu verarbeiten. Stellen Sie sich vor, Sie haben eine Liste mit Elementen und möchten etwas mit diesen Elementen tun (filtern, sortieren, zuordnen usw.). Mit einem Stream können Sie all das auf saubere und effiziente Weise erledigen. Es ist wie ein Fließband, an dem Ihre Daten verschiedene Schritte durchlaufen, bis sie verarbeitet werden.

Wichtige Dinge, die Sie bei Streams beachten sollten:

1. Streams ändern die Originaldaten nicht. Betrachten Sie sie als eine Ansicht oder eine Pipeline über Ihre Daten.
2. Streams verarbeiten Daten träge, was bedeutet, dass sie keine wirkliche Arbeit leisten, bis Sie ihnen sagen, dass sie ein Endergebnis liefern sollen. Dies vermeidet unnötige Berechnungen.
3. Streams sind zur einmaligen Verwendung gedacht. Sobald ein Stream verbraucht wurde, ist er weg. Sie müssen ein neues erstellen, wenn Sie es wiederverwenden möchten.

Warum Streams verwenden?

Warum nicht einfach eine for-Schleife verwenden oder Sammlungen direkt bearbeiten? Nun, es gibt drei Hauptgründe:

• Saubererer Code: Es ist nicht erforderlich, sich wiederholende, umfangreiche Schleifen zu schreiben. Streams bieten Ihnen eine saubere, lesbare Möglichkeit, Daten zu verarbeiten.
• Bessere Leistung: Mit Lazy Evaluation verarbeiten Streams Daten effizienter. Sie bearbeiten Daten nur bei Bedarf, was Verarbeitungszeit sparen kann.
• Funktionaler Stil: Streams bringen einen deklarativeren, funktionaleren Programmierstil in Java, was bedeutet, dass Sie sich auf was konzentrieren, das Sie tun möchten, und nicht auf wie.

Wie funktionieren Streams? Die Grundlagen

Werfen wir einen Blick auf die beiden Haupttypen von Stream-Operationen: Intermediate und Terminal.

1. Zwischenoperationen

Dies sind die Vorgänge, die die Daten vorbereiten, aber nicht sofort zu einem Endergebnis führen. Stellen Sie sich diese als „Workshop“-Schritte vor.

• Filter()

  Das ist wie ein Sieb. Es wählt Elemente basierend auf einer Bedingung aus. Wenn Sie beispielsweise nur die geraden Zahlen aus einer Liste von Ganzzahlen möchten, verwenden Sie filter().
  

  java
  Copy code
  List numbers = Arrays.asList(1, 2, 3, 4, 5);
  List evenNumbers = numbers.stream()
                                     .filter(n -> n % 2 == 0)
                                     .collect(Collectors.toList());
  // Output: [2, 4]
  
  

  Warum filtern? Ohne filter() müssten Sie die Liste manuell durchlaufen und nur die passenden Elemente zu einer neuen Liste hinzufügen. Mit filter() können Sie dies in einem sauberen Schritt erledigen.

• Karte()

  Dies ist ein Transformator. Es nimmt ein Element und gibt etwas anderes zurück. Wenn Sie beispielsweise eine Liste mit Zeichenfolgen haben und die Länge jeder Zeichenfolge angeben möchten:
  

  java
  Copy code
  List words = Arrays.asList("apple", "banana", "cherry");
  List lengths = words.stream()
                               .map(String::length)
                               .collect(Collectors.toList());
  // Output: [5, 6, 6]
  
  

  Warum Map? Map() wird verwendet, wenn Sie jedes Element in etwas anderes umwandeln müssen, beispielsweise eine Liste von Zeichenfolgen in eine Liste ihrer Längen umwandeln.

• unterscheidbar()

  Es ist wie ein Duplikatfilter. Dadurch werden doppelte Elemente aus einem Stream entfernt.
  

  java
  Copy code
  List numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
  List distinctNumbers = numbers.stream()
                                         .distinct()
                                         .collect(Collectors.toList());
  // Output: [1, 2, 3, 4, 5]
  
  

  Warum eindeutig? In einer normalen Liste müssten Sie manuell nach Duplikaten suchen. simply() erledigt dies für Sie in einer Zeile.

• sorted()

  Dadurch werden Ihre Daten in natürlicher Reihenfolge sortiert (oder in einer benutzerdefinierten Reihenfolge, wenn Sie möchten).
  

  java
  Copy code
  List names = Arrays.asList("Charlie", "Alice", "Bob");
  List sortedNames = names.stream()
                                  .sorted()
                                  .collect(Collectors.toList());
  // Output: ["Alice", "Bob", "Charlie"]
  
  

  Warum sortiert? Anstatt die Sortierlogik selbst zu schreiben, erledigt sorted() das für Sie.

2. Terminalbetrieb

Das sind diejenigen, die das Endergebnis erzeugen und die Verarbeitung des gesamten Streams auslösen. Stellen Sie sich diese als „Ausstiegspunkt“ vor.

• sammeln()

  Dies ist die häufigste Terminaloperation. Es sammelt die Ergebnisse des Streams und fügt sie in eine Liste, einen Satz oder eine andere Sammlung ein.
  

  java
  Copy code
  List names = Arrays.asList("Charlie", "Alice", "Bob");
  List upperNames = names.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList());
  // Output: ["CHARLIE", "ALICE", "BOB"]
  
  

  Warum sammeln? Sie verwenden fast immer Collect(), um die Ergebnisse Ihres Streams in einer Sammlung zu sammeln. Es ist Ihre letzte Station.

• forEach()

  Wenn Sie kein Ergebnis benötigen und nur eine Aktion für jedes Element ausführen möchten (z. B. sie drucken), ist forEach() Ihr Freund.
  

  java
  Copy code
  numbers.stream()
         .forEach(System.out::println);
  
  

  Warum forEach? Dies ist perfekt für Nebeneffekte, wie das Drucken von Daten auf der Konsole oder das Schreiben in eine Datei.

• reduzieren()

  reduce() nimmt eine Reihe von Daten und fasst sie zu einem einzigen Ergebnis zusammen. Summieren Sie beispielsweise eine Liste von Zahlen:
  

  java
  Copy code
  int sum = numbers.stream()
                   .reduce(0, Integer::sum);
  // Output: 15
  
  

  Warum reduzieren? Wenn Sie Werte in einem einzigen Ergebnis kombinieren oder akkumulieren müssen, ist Reduce() Ihre erste Wahl.

Andere Arten von Streams

Nicht alle Streams werden aus Sammlungen erstellt. Java bietet andere Arten von Streams zur Verarbeitung verschiedener Arten von Daten:

1. IntStream, LongStream, DoubleStream

   Diese Streams sind auf den Umgang mit primitiven Typen spezialisiert. Anstelle von Boxing- und Unboxing-Werten wie „Stream“ verwenden Sie diese, um Leistungseinbußen zu vermeiden.

   Beispiel:
   

   java
   Copy code
   IntStream intStream = IntStream.of(1, 2, 3, 4);
   int sum = intStream.sum();  // Output: 10
   
   

2. Datenstrom

   Sie können Streams aus Dateien mit Files.lines() erstellen.
   

   java
   Copy code
   try (Stream lines = Files.lines(Paths.get("data.txt"))) {
       lines.forEach(System.out::println);
   } catch (IOException e) {
       e.printStackTrace();
   }
   
   

   Warum Dateistreams verwenden? Beim Umgang mit großen Dateien ist das Laden aller Daten in den Speicher möglicherweise nicht effizient. Wenn Sie einen Stream verwenden, können Sie ihn Zeile für Zeile verarbeiten.

Wann sollten Streams verwendet werden?

• Daten transformieren: Wenn Sie jedes Element einer Sammlung ändern müssen.
• Filtern: Wenn Sie nur die Daten auswählen möchten, die bestimmte Bedingungen erfüllen.
• Daten aggregieren: Wenn Sie eine Sammlung auf ein einzelnes Ergebnis reduzieren müssen (z. B. Summe, Durchschnitt).
• Parallelverarbeitung: Streams unterstützen auch Parallelität. Mit .parallelStream() können Sie Ihre Aufgaben zur schnelleren Verarbeitung auf mehrere Threads aufteilen.

Stream vs. Loops: Warum nicht einfach Loops verwenden?

Gute Frage! Vergleichen wir:

1. Lesbarkeit: Mit Streams konzentrieren Sie sich auf was Sie tun möchten, nicht auf wie. Bei Schleifen müssen Sie in der Regel viel zusätzlichen Standardcode schreiben (z. B. Zähler und Bedingungen).
2. Leistung: Streams sind für die effiziente Verarbeitung großer Datenmengen optimiert, insbesondere mit verzögerter Auswertung und Parallelität. Schleifen bieten solche sofort einsatzbereiten Optimierungen nicht.
3. Flexibilität: Mit Streams können Sie Vorgänge (wie Filtern, Zuordnen und Reduzieren) in einem klaren, funktionalen Stil verketten. Schleifen würden erfordern, dass Sie mehr Logik darin verschachteln.

Zusammenfassung

Bei Streams in Java geht es darum, die Art und Weise zu vereinfachen, wie Sie Daten verarbeiten. Sie machen Ihren Code lesbarer, einfacher zu warten und effizienter bei der Arbeit mit Sammlungen. Egal, ob Sie Daten filtern, transformieren oder reduzieren, Streams bietet Ihnen klare, unkomplizierte Methoden, die aufwändige Schleifen und manuelle Arbeit überflüssig machen.

Da Sie nun mit den Grundlagen von Streams vertraut sind, warum sollten Sie hier aufhören? Folgen Sie mir auf Twitter, LinkedIn oder schauen Sie sich meinen Blog an, um weitere Java-Tipps zu erhalten, die Sie im Handumdrehen zum Profi machen! Und wenn Sie diesen Leitfaden hilfreich fanden, teilen Sie ihn mit Ihren Entwicklerkollegen – denn Teilen ist wichtig!

Bereit, es auszuprobieren? Lassen Sie uns den Stream in Ihrem nächsten Projekt zum Fließen bringen!