In diesem Tutorial werden Array -Elemente effizient filtern und neue Arrays basierend auf bestimmten Bedingungen in Java generieren. Wir werden zun?chst die Einschr?nkungen der traditionellen Dual-Loop-Methode analysieren und sich dann darauf konzentrieren, wie die von Java 8 eingeführte Stream-API verwendet wird, um die Filtervorg?nge mit Hochleistungsarray-Filterung auf eine kurze und deklarative Weise zu erreichen, wodurch die Lesbarkeit und Ausführungseffizienz des Codes verbessert wird.

Herausforderungen traditioneller Array -Filtermethoden

Wenn wir in Java Elemente herausfiltern müssen, die die Kriterien auf der Grundlage bestimmter Bedingungen (z. B. alle Werte gr??er als ein bestimmter Schwellenwert) aus einem vorhandenen Array erfüllen und in ein neues Array versetzen, besteht ein gemeinsamer, aber ineffizienter Ansatz darin, zwei unabh?ngige Schleifen zu verwenden.

Betrachten Sie die folgende traditionelle Methodenimplementierung:

 ?ffentliche Klasse ArrayFilterlegacy {
    public int [] GetValuesabovethreshold (int [] Daten, int Schwelle) {
        // Schritt 1: Durch das Array iterieren und die Anzahl der Elemente berechnen, die den Bedingungen erfüllen, um die Gr??e des neuen Int -Z?hlers = 0 zu bestimmen;
        für (int i = 0; i <data.length i if> Schwelle) {
                Schalter ;
            }
        }

        // Erstellen Sie ein neues Array int [] shresholdArray = new int [counter];

        // Schritt 2: Iterieren Sie erneut über das Array und füllen Sie die Elemente, die die Bedingungen in das neue Array int count = 0 erfüllen.
        für (int i = 0; i <data.length i if> Schwelle) {
                thresholdArray [count] = data [i];
                z?hlen ;
            }
        }
        Return ThresholdArray;
    }
}</data.length></data.length>

Obwohl diese Methode funktional machbar ist, hat sie offensichtliche Einschr?nkungen:

1. Zwei Travers: Zwei vollst?ndige Traverals sind erforderlich, um zwei vollst?ndige Traverals auf dem Original -Array durchzuführen. Das erste Mal besteht darin, die genaue Gr??e des Neuarrays zu bestimmen, und das zweite Mal ist das Ausfüllen der Daten wirklich. Dies fügt unn?tigen Rechenaufwand hinzu, insbesondere für gro?e Arrays.
2. Code -Redundanz: Die bedingte Beurteilungslogik der beiden Loops ist nahezu gleich, was zu einer Duplikation des Codes führt.
3. Manuelles Management: Der Index von Z?hlern und Neuen Arrays muss manuell verwaltet werden, wodurch die M?glichkeit von Fehlern erh?ht wird (z. B. Index au?erhalb der Grenzen oder Z?hlfehler).

Stream -API: Eine moderne Art zur effizienten Filterung

Die von Java 8 eingeführte Stream -API bietet eine sauberere, effizientere und deklarativere M?glichkeit für Prozesserfassung, einschlie?lich Arrays. Durch den Stream k?nnen wir die oben genannten zwei Durchfahrten in einen reibungslosen Kettenbetrieb kombinieren.

Die Kernidee der Stream -API besteht darin, die Datenquelle (z. B. Arrays, S?tze) als eine Abfolge von Elementen zu betrachten und eine Reihe von Zwischenoperationen (wie Filter, MAP, Sortiert) und eine terminale Operation (wie Toarrray, foreach, Reduzierung) durchzuführen.

Hier ist ein Beispielcode zum Implementieren von Array -bedingter Filterung mithilfe der Stream -API:

 Import Java.util.Arrays;

?ffentliche Klasse StreamArrayFilter {

    /**
     * Filtern Sie Elemente heraus, die gr??er als der Schwellenwert des ursprünglichen Arrays entsprechend dem angegebenen Schwellenwert sind, und geben Sie ein neues Array zurück.
     *
     * @param originalArray originalInteger Array.
     * @param Schwellenwertfilterschwelle.
     * @return enth?lt alle Neuarrays von Elementen, die gr??er als der Schwellenwert sind.
     */
    private static int [] GetValuesabovethreshold (int [] originalArray, int Schwelle) {
        RETUCT ARAYS.Stream (OriginalArray) // 1. Konvertieren Sie das Original -Array in Intstream
                     .Filter (val -> val> Schwellenwert) // 2. Filterbedingungen anwenden: Nur Elemente, die gr??er als der Schwellenwert sind, werden beibehalten.Array (); // 3.. Sammeln Sie die gefilterten Stream -Elemente zurück zu einem neuen INT -Array}

    public static void main (String [] args) {
        int Schwelle = 4;
        int [] data = new int [] {1, 2, 3, 4, 5, 6, 7, 8, 9};

        // Stream -API zur Filterung int [] filteredArray = GetValuesAvethreshold (Daten, Schwellenwert) verwenden;

        System.out.println ("RAW -Array:" Arrays.toString (Daten));
        System.out.println ("Schwelle:" Schwelle);
        System.out.println ("FilteredResult:" Arrays.toString (filteredArray)); // Ausgabe: [5, 6, 7, 8, 9]
    }
}

Code Parsen:

1. Arrays.Stream (OriginalArray) : Dies ist der Ausgangspunkt der Stream -Operation. Die Arrays -Tool -Klasse bietet einen statischen Methodenstream (), mit dem ein Array von primitiven Typen (z. B. int []) in einen entsprechenden spezifischen Strom (z. B. intstream) konvertiert werden kann.
2. .Filter (VALL -> VAL> Schwellenwert) : Dies ist eine Zwischenoperation. Die filter () -Methode empf?ngt eine Pr?dikat (funktionale Schnittstelle), die die Filterbedingungen definiert. Hier verwenden wir den Lambda -Expression VAL -> VAL> Schwellenwert, was bedeutet, dass nur Elemente mit Werten gr??er als Schwellenwert erhalten bleiben.
3. .toArray () : Dies ist eine Terminaloperation. Es sammelt die verbleibenden Elemente im Stream in ein neues Array und kehrt zurück. Für IntStream gibt es ein neues Int [] -Array zurück und verarbeitet automatisch die Gr??e des neuen Arrays, ohne es vorab zu tun zu haben.

Vorteile der Stream -API

Die Verwendung der Stream -API für die Array -Filterung bietet viele Vorteile:

• Einfachheit und Lesbarkeit: Der Code ist kompakter und ausdrucksst?rker. Durch Kettenaufrufe ist der Datenverarbeitungsprozess auf einen Blick klar und verbessert die Lesbarkeit des Codes.
• Deklarative Programmierung: Sie deklarieren nur "was zu tun" (Filterelemente gr??er als der Schwellenwert und dann sammeln), ohne dass "wie man" im Detail angegeben ist (manuelles Schleifen, Z?hlen, Erstellen von Arrays). Dies erleichtert den Code leichter zu verstehen und zu warten.
• Effizienz: Die Stream -API wird intern optimiert und kann in der Regel den Betrieb in einer einzigen Durchführung abschlie?en. Für gro?e Datens?tze unterstützt die Stream -API sogar die parallele Verarbeitung (über Parallelsstream ()), was die Leistung weiter verbessert.
• Vermeiden Sie manuelle Fehler: Sie müssen keine Array -Indizes und -gr??en manuell verwalten und Fehler reduzieren, die durch manuelle Vorg?nge eingeführt werden.
• Leistungsstark: Die Stream -API ist nicht auf Filterung beschr?nkt, sondern unterstützt auch eine Vielzahl fortschrittlicher Vorg?nge wie Karten, sortiert, dedupliziert und reduziert, wobei ein reichhaltiges Tool für die Datenverarbeitung bereitgestellt wird.

Notizen und Best Practices

• Lazy Evaluation: Die Zwischenoperationen von Stream werden faul ausgeführt und sie werden nur tats?chlich ausgeführt, wenn der Terminalvorgang aufgerufen wird. Dies bedeutet, dass Stream unendliche Sequenzen verarbeiten und nur die erforderlichen Teile verarbeiten kann.
• Nicht wiederverwendbar: Sobald der Terminalbetrieb des Streams aufgerufen wurde, ist der Strom "verbraucht" und kann nicht erneut verwendet werden. Wenn Sie mehrere Stream -Vorg?nge für die gleichen Daten durchführen müssen, sollten Sie den Stream für jeden Vorgang neu erstellen.
• Leistungsüberlegungen: Bei sehr kleinen Arrays k?nnen die Leistungsunterschiede zwischen herk?mmlichen Schleifen und Stream -APIs minimal sein. Aus Sicht des Codestils, der Lesbarkeit und der zukünftigen Skalierbarkeit (wie Parallelisierung) ist die Stream -API jedoch normalerweise eine bessere Wahl.
• Parallele Stream: Für Szenarien, in denen gro?e Datenmengen erforderlich sind, kann Parallelstream () als Multi-Core-Prozessoren angesehen werden, um paralleles Computer durchzuführen, um die Leistung weiter zu verbessern. Beachten Sie jedoch, dass parallele Streams nicht immer schneller sind, sondern zus?tzlichen Overheads einführt und sicherstellen muss, dass die Operationen auf Stauro und den Thread sind.

Zusammenfassen

Die Java -Stream -API bietet eine leistungsstarke und elegante L?sung für die Datenverarbeitung von Arrays und Sammlungen. Durch die Verwendung von Kettenoperationen wie Arrays.Stream (). Filter (). TOARRAY () k?nnen wir uns von den umst?ndlichen und Ineffizienz herk?mmlicher Dual -Loops verabschieden und eine komplexe bedingte Filterlogik auf pr?gnante, lesbare und skalierbare Weise implementieren. Das Mastering-Stream-API ist eine Muss für moderne Java-Entwickler, die die Qualit?t und die Entwicklungseffizienz der Code erheblich verbessern k?nnen.

Das obige ist der detaillierte Inhalt vonJava Stream API: Tutorial für effiziente Filterarray -Elemente. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!