Lära Begränsning och Överhoppning av Element med Metoderna limit() och skip()

Java Stream API tillhandahåller bekväma metoder för att arbeta med datakollektioner. Två användbara metoder, limit() och skip(), gör det möjligt att styra hur många element som behandlas i en stream eller att hoppa över ett visst antal element, vilket kan vara användbart för att optimera prestanda vid hantering av stora datamängder.

Vad är dessa metoder?

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
    }
}

I detta exempel används limit(10) för att begränsa strömmen till de första 10 elementen, vilket säkerställer att endast dessa objekt behandlas.

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
    }
}

Här används skip(5) för att ignorera de första fem objekten och påbörja bearbetningen från det sjätte objektet och framåt.

Exempel från verkligheten

Föreställ dig att du arbetar på en fabrik med en lista på 50 delar som behöver inspekteras. Du behöver endast kontrollera de första 10 delarna medan en annan specialist hanterar resten. I detta fall kan du använda limit(10).

Om de första 20 delarna redan har blivit inspekterade och du behöver börja från del 21, kan du använda skip(20).

Nu ska vi implementera detta scenario i kod.

Praktisk tillämpning

På en fabrik behöver du bearbeta delar. Du har en lista på 50 delar och behöver hoppa över de första 20, sedan bearbeta de nästa 10.

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 + "'}";
    }
}

I denna kod används en Supplier för att dynamiskt skapa Part-objekt. UUID-biblioteket hjälper till att generera unika identifierare för varje del.

Med Stream.generate(partSupplier), som tar vår Supplier, skapas en ström av delar som fortsätter att generera element tills du begränsar den med limit(50).

Därefter säkerställer skip(20) att de första 20 delarna ignoreras, medan limit(10) endast behandlar de nästkommande 10 delarna.

Detta tillvägagångssätt möjliggör effektiv datagenerering och bearbetning utan att behöva lagra hela listan i minnet.

1. Vad gör metoden `limit(n)` i en ström?

2. Vilket gränssnitt används för att generera element i en ström med `Stream.generate()`?

3. Vilken metod hoppar över de första `n` elementen i en stream?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 9

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 2.33

Svep för att visa menyn

Vad är dessa metoder?

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
    }
}

I detta exempel används limit(10) för att begränsa strömmen till de första 10 elementen, vilket säkerställer att endast dessa objekt behandlas.

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
    }
}

Här används skip(5) för att ignorera de första fem objekten och påbörja bearbetningen från det sjätte objektet och framåt.

Exempel från verkligheten

Om de första 20 delarna redan har blivit inspekterade och du behöver börja från del 21, kan du använda skip(20).

Nu ska vi implementera detta scenario i kod.

Praktisk tillämpning

På en fabrik behöver du bearbeta delar. Du har en lista på 50 delar och behöver hoppa över de första 20, sedan bearbeta de nästa 10.

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 + "'}";
    }
}

I denna kod används en Supplier för att dynamiskt skapa Part-objekt. UUID-biblioteket hjälper till att generera unika identifierare för varje del.

Med Stream.generate(partSupplier), som tar vår Supplier, skapas en ström av delar som fortsätter att generera element tills du begränsar den med limit(50).

Därefter säkerställer skip(20) att de första 20 delarna ignoreras, medan limit(10) endast behandlar de nästkommande 10 delarna.

Detta tillvägagångssätt möjliggör effektiv datagenerering och bearbetning utan att behöva lagra hela listan i minnet.

1. Vad gör metoden `limit(n)` i en ström?

2. Vilket gränssnitt används för att generera element i en ström med `Stream.generate()`?

3. Vilken metod hoppar över de första `n` elementen i en stream?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 9

Begränsning och Överhoppning av Element med Metoderna limit() och skip()

Vad är dessa metoder?

Exempel från verkligheten

Praktisk tillämpning

1. Vad gör metoden limit(n) i en ström?

2. Vilket gränssnitt används för att generera element i en ström med Stream.generate()?

3. Vilken metod hoppar över de första n elementen i en stream?

Awesome!

Begränsning och Överhoppning av Element med Metoderna limit() och skip()

Vad är dessa metoder?

Exempel från verkligheten

Praktisk tillämpning

1. Vad gör metoden limit(n) i en ström?

2. Vilket gränssnitt används för att generera element i en ström med Stream.generate()?

3. Vilken metod hoppar över de första n elementen i en stream?

1. Vad gör metoden `limit(n)` i en ström?

2. Vilket gränssnitt används för att generera element i en ström med `Stream.generate()`?

3. Vilken metod hoppar över de första `n` elementen i en stream?

1. Vad gör metoden `limit(n)` i en ström?

2. Vilket gränssnitt används för att generera element i en ström med `Stream.generate()`?

3. Vilken metod hoppar över de första `n` elementen i en stream?