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

Die Java Stream API stellt praktische Methoden für die Arbeit mit Datensammlungen bereit. 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 einer Inspektion bedürfen. Sie müssen nur die ersten 10 Teile prüfen, während ein anderer Spezialist den Rest übernimmt. In diesem Fall können Sie limit(10) verwenden.

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

Nun wird dieses Szenario im Code umgesetzt.

Praktische Anwendung

In einer Fabrik müssen Teile verarbeitet werden. Es gibt eine Liste von 50 Teilen und die ersten 20 sollen übersprungen werden, danach werden die nächsten 10 verarbeitet.

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 dynamisch Part-Objekte 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 Datengenerierung und -verarbeitung, ohne dass die gesamte Liste im Speicher gehalten werden muss.

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

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

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

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 9

Fragen Sie AI

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

Suggested prompts:

Can you show me the code example for this scenario?

What is the difference between limit() and skip() in practice?

Are there any performance considerations when using these methods?

Awesome!

Completion rate improved to 2.33

Swipe um das Menü anzuzeigen

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

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

Nun wird dieses Szenario im Code umgesetzt.

Praktische Anwendung

In einer Fabrik müssen Teile verarbeitet werden. Es gibt eine Liste von 50 Teilen und die ersten 20 sollen übersprungen werden, danach werden die nächsten 10 verarbeitet.

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 dynamisch Part-Objekte 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 Datengenerierung und -verarbeitung, ohne dass die gesamte Liste im Speicher gehalten werden muss.

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

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

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

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 9

Einschränkung 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 mit Stream.generate() Elemente in einem Stream zu erzeugen?

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

Awesome!

Einschränkung 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 mit Stream.generate() Elemente in einem Stream 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 mit `Stream.generate()` Elemente in einem Stream 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 mit `Stream.generate()` Elemente in einem Stream zu erzeugen?

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