Die beiden Kernmerkmale von Java 8 sind Lambda -Ausdrücke und Stream -API, die den Code pr?gnanter, lesbar und funktionaler machen. 1. Lambda -Ausdrücke sind anonyme Funktionen, die zur Vereinfachung der Implementierung funktionaler Schnittstellen verwendet werden, z. 2. Die Stream -API enth?lt eine deklarative Datenverarbeitungspipeline, die Kettenoperationen wie Filter, Karte, Reduzierung usw. unterstützt; 3.. Zwischenvorg?nge (wie Filter, Karte) sind faul und terminale Operationen (z. B. Foreach, sammeln) Triggerausführung; 4. H?ufige Muster umfassen die Filterkartierung, die Flachmapabflachung, die Reduzierung der Aggregation und die Sammlungsergebnisse der Sammlung; 5. Zu den Best Practices geh?rt die Vermeidung von Nebenwirkungen, die Wiederverwendung von Streams und die Verwendung von Parallelstream mit Vorsicht; 6. Nicht für einfache Schleifen oder leistungsempfindliche Szenarien geeignet. Das Mastering kann die Effizienz und die Codequalit?t der Sammlungsverarbeitung erheblich verbessern, was eine notwendige F?higkeit für die moderne Java -Entwicklung darstellt.

Java 8 führte zwei bahnbrechende Funktionen vor: Lambda-Ausdrücke und die Stream-API . Gemeinsam revolutionierten sie, wie Entwickler den Java -Code schreiben, lesen und pflegen - insbesondere im Umgang mit Sammlungen. Dieser Leitfaden führt Sie durch beide Konzepte mit praktischen Beispielen, gemeinsamen Mustern und Best Practices.

Was sind Lambda -Ausdrücke?

Ein Lambda -Ausdruck ist eine kurze Methode, um eine anonyme Funktion darzustellen - ein Codeblock, der sp?ter weitergegeben und ausgeführt werden kann. Es ist besonders nützlich für die funktionale Programmierung in Java.

Vor Java 8 würden Sie h?ufig anonyme innere Klassen verwenden:

 Collectionss.sort (Namen, neuer Komparator <string> () {
    public int compare (Zeichenfolge A, Zeichenfolge b) {
        return A. compareto (b);
    }
});

Bei Lambdas wird der gleiche Code:

 Collections.sort (Namen, (a, b) -> A. compareto (b));

Syntax einer Lambda

 (Parameter) -> Ausdruck

Oder für mehrere Aussagen:

 (Parameter) -> {Anweisungen; }

Schlüsselpunkte:

• Lambdas funktionieren nur mit funktionellen Schnittstellen (Schnittstellen mit genau einer abstrakten Methode).
• H?ufige funktionelle Schnittstellen in java.util.function umfassen:
  • Predicate<T> : boolean test(T t)
  • Function<T, R> : R apply(T t)
  • Consumer<T> : void accept(T t)
  • Supplier<T> : T get()
  • UnaryOperator<T> , BinaryOperator<T>

Beispiel Verwendung

 Liste <String> names = arrays.aslist ("Alice", "Bob", "Charlie");

// Pr?dikat: Filternamen beginnend mit "a"
Pr?dikat <string> startsWitha = name -> name.startswith ("a");
names.stream ()
     .Filter (Startswitha)
     .foreach (System.out :: println); // Ausgabe: Alice

Hinweis: System.out::println ist eine Methodenreferenz , Kurzschrift für x -> System.out.println(x) .

Einführung in Streams

Mit der Stream -API k?nnen Sie Sequenzen von Elementen (wie Sammlungen) auf deklarative Weise verarbeiten - was zu tun ist, nicht wie es zu tun ist.

Streams sind keine Datenstrukturen. Sie speichern keine Daten, noch ?ndern sie die Quelle. Stattdessen tragen sie Daten über eine Operationspipeline.

Erstellen eines Streams

 // aus einer Sammlung
Liste <String> list = arrays.aslist ("a", "b", "c");
Stream <string> Stream = list.stream ();

// aus einem Array
Stream <Gearner> arrstream = arrays.stream (New Integer [] {1, 2, 3});

// aus Werten
Stream <String> Valuestream = Stream.of ("Hallo", "Welt");

// Infinite Streams
Stream.Etateer (0, n -> n 2) .Limit (5); // 0, 2, 4, 6, 8

Stream -Operationen: Intermediate vs Terminal

Streams unterstützen eine Kette von Operationen, die in zwei Arten unterteilt sind:

1. Zwischenvorg?nge (Rückgabe eines neuen Streams)

Diese sind faul - sie werden erst ausgeführt, wenn eine Terminaloperation aufgerufen wird.

• filter(Predicate)
• map(Function)
• flatMap(Function)
• distinct()
• sorted()
• peek(Consumer)
• limit(n)
• skip(n)

2. Terminalvorg?nge (Triggerverarbeitung)

Diese verbrauchen den Strom und erzeugen ein Ergebnis oder einen Nebeneffekt.

• forEach(Consumer)
• collect(Collector)
• reduce(BinaryOperator)
• count()
• anyMatch(Predicate)
• findFirst()
• toArray()

Beispielpipeline

 Liste <String> result = names.stream ()
    filter (name -> name.length ()> 4)
    .Map (String :: Touppercase)
    .Sortiert ()
    .Collect (sammel.tolist ());

Dies lautet natürlich: "Filtern Sie lange Namen, konvertieren Sie in Gro?buchstaben, sortieren und sammeln."

Gemeinsame Strommuster

Filterung und Zuordnung

 LIST <NEger> nums = arrays.aSlist (1, 2, 3, 4, 5, 6);

LIST <NEGEGER> EVENSQUARES = NUMS.Stream ())
    .Filter (n -> n % 2 == 0)
    .Map (n -> n * n)
    .Collect (sammel.tolist ()); // [4, 16, 36]

Flatmap für verschachtelte Strukturen

Verwenden Sie flatMap , um B?che von B?chen abzuflachen.

 Liste <list <string >> listoflists = arrays.aslist (
    Arrays.aSlist ("a", "B"),
    Arrays.aSlist ("C", "D")
);

List <String> alle = listoflists.stream ()
    .FlatMap (Liste :: Stream)
    .Collect (sammel.tolist ()); // ["A", "B", "C", "D"]

Reduktion mit reduce()

 Optional <Integer> sum = nums.stream ()
    .Reduce ((a, b) -> ab); // Optional [21]

Oder mit Identit?t:

 int Total = nums.stream (). Reduzieren (0, Integer :: sum); // 21

Ergebnisse sammeln

Collectors ist Ihr Anlaufsatz für das Sammeln von Stream-Ausgaben.

 // zur Liste
List <String> list = Stream.collect (collectors.tolist ());

// zu setzen
Set <String> set = stream.collect (sollectors.toset ());

// zu String mit dem Beitritt
String JoinNe = Stream.Collect (Collectors.Joining (","));

// Gruppierung nach einer Immobilie
Karte <Integer, Liste <String >> bylength = names.stream ()
    .Collect (Sammler.GroupingBy (String :: L?nge));

Beispiel:

 // Gruppennamen nach L?nge
{
    3: ["Bob"],
    5: ["Alice"],
    7: ["Charlie"]
}

Partitionierung

Auf der Grundlage einer Vorhersage aufgeteilt:

 Karte <boolean, Liste <String >> partitioned = names.stream ()
    .Collect (Sammler.
// wahr: [Alice], Falsch: [Bob, Charlie]

Leistung und Best Practices

• Streams sind faul : Zwischenvorg?nge werden erst ausgeführt, wenn der Terminalbetrieb aufgerufen wird.
• Vermeiden Sie Nebenwirkungen in Lambdas. Sie sollten staatenlos sein.
• Bevorzugen Sie Streams für die Lesbarkeit, aber nicht übereinstimmen sie für einfache Schleifen.
• Verwenden Sie parallelStream() mit Vorsicht - nur wenn die Daten gro? und die Operationen unabh?ngig sind.
• Wiederverwenden Streams: Ein Stream kann nur einmal konsumiert werden.

 Stream <String> s = list.stream ();
S.Forach (System.out :: println); // OK
S.Forach (System.out :: println); // illegalStateException!

Wenn keine Streams verwendet werden

• Einfache Schleifen mit Nebenwirkungen (z. B. Aktualisierung externer Variablen).
• Leistungskritische Schleifen, bei denen Overhead wichtig ist.
• Wenn der Code weniger lesbar wird (z. B. tief verschachtelte Fladenmaps).

Manchmal ist eine Ebene for die Schleife klarer.

Zusammenfassung

Die Lambdas und Streams von Java 8 machen Code ausdrucksst?rker und funktionaler. Du kannst:

• Ersetzen Sie ausführliche anonyme Klassen durch saubere Lambda -Syntax.
• Kettenvorg?nge auf Daten mit Streams.
• Verwenden Sie integrierte Sammler zum Gruppieren, Beitritt und Reduzieren.
• Schreiben Sie deklarativen, lesbaren Code.

Sie ersetzen traditionelle Schleifen nicht vollst?ndig, aber sie sind leistungsstarke Werkzeuge, wenn sie angemessen verwendet werden.

Wenn Sie mit Sammlungen in Java arbeiten, ist es wichtig, dass das Lernen von Streams und Lambdas wichtig ist - und wenn Sie sich an sie gew?hnt haben, werden Sie sich fragen, wie Sie ohne gelebt haben.

Das obige ist der detaillierte Inhalt vonEin umfassender Leitfaden zu Java 8 -Streams und Lambdas. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!