Lernen Einschränken und Überspringen von Elementen mit den Methoden Limit() und Skip()

Swipe um das Menü anzuzeigen

Die Java Stream API bietet praktische Methoden zur Arbeit mit Datensammlungen. Zwei nützliche Methoden, limit() und skip(), ermöglichen die Kontrolle darüber, wie viele Elemente in einem Stream verarbeitet werden oder wie viele Elemente übersprungen werden. Dies kann bei der Optimierung der Leistung beim Umgang mit großen Datensätzen hilfreich sein.

Was sind diese Methoden?

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> products = Arrays.asList(
                "Item 1", "Item 2", "Item 3", "Item 4", "Item 5",
                "Item 6", "Item 7", "Item 8", "Item 9", "Item 10",
                "Item 11", "Item 12"
        );

        // Limit processing to the first 10 items
        products.stream()
                .limit(10)
                .forEach(System.out::println); // Output: Item 1, Item 2, ..., Item 10
    }
}

In diesem Beispiel wird limit(10) verwendet, um den Stream auf die ersten 10 Elemente zu beschränken, sodass nur diese Elemente verarbeitet werden.

Main.java


              1234567891011121314151617181920
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> products = Arrays.asList(
                "Item 1", "Item 2", "Item 3", "Item 4", "Item 5",
                "Item 6", "Item 7", "Item 8", "Item 9", "Item 10",
                "Item 11", "Item 12"
        );

        // Skip the first 5 items and process the rest
        products.stream()
                .skip(5)  // Skips the first 5 items
                .forEach(System.out::println); // Output: Item 6, Item 7, ..., Item 12
    }
}

Hier wird skip(5) verwendet, um die ersten fünf Elemente zu überspringen und die Verarbeitung ab dem sechsten Element zu beginnen.

Praxisbeispiel

Stellen Sie sich vor, Sie arbeiten in einer Fabrik mit einer Liste von 50 Teilen, die geprüft werden müssen. Sie müssen nur die ersten 10 Teile kontrollieren, während ein anderer Spezialist den Rest übernimmt. In diesem Fall können Sie limit(10) verwenden.

Wenn die ersten 20 Teile bereits geprüft wurden und Sie ab Teil 21 beginnen müssen, können Sie skip(20) verwenden.

Nun wollen wir dieses Szenario im Code umsetzen.

Praktische Anwendung

In einer Fabrik müssen Teile verarbeitet werden. Sie haben eine Liste von 50 Teilen und müssen die ersten 20 überspringen, dann die nächsten 10 verarbeiten.

Main.java


              12345678910111213141516171819202122232425262728293031323334353637
            
package com.example;

import java.util.UUID;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // Supplier for generating parts
        Supplier<Part> partSupplier = () -> new Part(
                (int) (Math.random() * 1000),
                "Part-" + UUID.randomUUID()
        );

        // Create a stream of 50 parts, skip the first 20, and process the next 10
        Stream.generate(partSupplier)
                .limit(50)  // Limit the stream to 50 parts
                .skip(20)   // Skip the first 20
                .limit(10)  // Process the next 10
                .forEach(System.out::println);  // Print the parts
    }
}

class Part {
    private int id;
    private String name;

    Part(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Part{id=" + id + ", name='" + name + "'}";
    }
}

In diesem Code wird ein Supplier verwendet, um Part-Objekte dynamisch zu erstellen. Die UUID-Bibliothek hilft dabei, eindeutige Kennungen für jedes Teil zu generieren.

Mit Stream.generate(partSupplier), das unseren Supplier übernimmt, wird ein Stream von Teilen erzeugt, der fortlaufend Elemente generiert, bis er mit limit(50) begrenzt wird.

Anschließend sorgt skip(20) dafür, dass die ersten 20 Teile übersprungen werden, während limit(10) nur die nächsten 10 Teile verarbeitet.

Dieser Ansatz ermöglicht eine effiziente Datenerzeugung und Verarbeitung, ohne die gesamte Liste im Speicher halten zu müssen.

1. Was bewirkt die Methode `limit(n)` in einem Stream?

2. Welches Interface wird verwendet, um Elemente in einem Stream mit `Stream.generate()` zu erzeugen?

3. Welche Methode überspringt die ersten `n` Elemente in einem Stream?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 24

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Abschnitt 1. Kapitel 24

Einschränken und Überspringen von Elementen mit den Methoden Limit() und Skip()

Was sind diese Methoden?

Praxisbeispiel

Praktische Anwendung

1. Was bewirkt die Methode limit(n) in einem Stream?

2. Welches Interface wird verwendet, um Elemente in einem Stream mit Stream.generate() zu erzeugen?

3. Welche Methode überspringt die ersten n Elemente in einem Stream?

1. Was bewirkt die Methode `limit(n)` in einem Stream?

2. Welches Interface wird verwendet, um Elemente in einem Stream mit `Stream.generate()` zu erzeugen?

3. Welche Methode überspringt die ersten `n` Elemente in einem Stream?