Lære Begrænsning og Udeladelse af Elementer med Metoderne limit() og skip()

Java Stream API tilbyder praktiske metoder til at arbejde med datasamlinger. To nyttige metoder, limit() og skip(), gør det muligt at kontrollere, hvor mange elementer der behandles i en stream, eller springe et bestemt antal elementer over, hvilket kan være nyttigt for at optimere ydeevnen ved håndtering af store datasæt.

Hvad er disse 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 dette eksempel bruges limit(10) til at begrænse streamen til de første 10 elementer, hvilket sikrer, at kun disse elementer bliver behandlet.

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

Her bruges skip(5) til at ignorere de første fem elementer og starte behandlingen fra det sjette element og frem.

Virkeligt eksempel

Forestil dig, at du arbejder på en fabrik med en liste over 50 dele, der skal inspiceres. Du behøver kun at kontrollere de første 10 dele, mens en anden specialist håndterer resten. I dette tilfælde kan du bruge limit(10).

Hvis de første 20 dele allerede er blevet inspiceret, og du skal starte fra del 21, kan du bruge skip(20).

Lad os nu implementere dette scenarie i kode.

Praktisk anvendelse

På en fabrik skal du behandle dele. Du har en liste over 50 dele og skal springe de første 20 over, derefter behandle de næste 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 denne kode bruges en Supplier til dynamisk at oprette Part-objekter. UUID-biblioteket hjælper med at generere unikke identifikatorer for hver del.

Ved at bruge Stream.generate(partSupplier), som tager vores Supplier, oprettes en stream af dele, der fortsætter med at generere elementer, indtil du begrænser den med limit(50).

Dernæst sikrer skip(20), at de første 20 dele ignoreres, mens limit(10) kun behandler de næste 10 dele.

Denne tilgang muliggør effektiv datagenerering og behandling uden at skulle gemme hele listen i hukommelsen.

1. Hvad gør metoden `limit(n)` i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode springer de første `n` elementer over i en stream?

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 9

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

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

Stryg for at vise menuen

Hvad er disse 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 dette eksempel bruges limit(10) til at begrænse streamen til de første 10 elementer, hvilket sikrer, at kun disse elementer bliver behandlet.

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

Her bruges skip(5) til at ignorere de første fem elementer og starte behandlingen fra det sjette element og frem.

Virkeligt eksempel

Hvis de første 20 dele allerede er blevet inspiceret, og du skal starte fra del 21, kan du bruge skip(20).

Lad os nu implementere dette scenarie i kode.

Praktisk anvendelse

På en fabrik skal du behandle dele. Du har en liste over 50 dele og skal springe de første 20 over, derefter behandle de næste 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 denne kode bruges en Supplier til dynamisk at oprette Part-objekter. UUID-biblioteket hjælper med at generere unikke identifikatorer for hver del.

Ved at bruge Stream.generate(partSupplier), som tager vores Supplier, oprettes en stream af dele, der fortsætter med at generere elementer, indtil du begrænser den med limit(50).

Dernæst sikrer skip(20), at de første 20 dele ignoreres, mens limit(10) kun behandler de næste 10 dele.

Denne tilgang muliggør effektiv datagenerering og behandling uden at skulle gemme hele listen i hukommelsen.

1. Hvad gør metoden `limit(n)` i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode springer de første `n` elementer over i en stream?

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 9

Begrænsning og Udeladelse af Elementer med Metoderne limit() og skip()

Hvad er disse metoder?

Virkeligt eksempel

Praktisk anvendelse

1. Hvad gør metoden limit(n) i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med Stream.generate()?

3. Hvilken metode springer de første n elementer over i en stream?

Awesome!

Begrænsning og Udeladelse af Elementer med Metoderne limit() og skip()

Hvad er disse metoder?

Virkeligt eksempel

Praktisk anvendelse

1. Hvad gør metoden limit(n) i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med Stream.generate()?

3. Hvilken metode springer de første n elementer over i en stream?

1. Hvad gør metoden `limit(n)` i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode springer de første `n` elementer over i en stream?

1. Hvad gør metoden `limit(n)` i en stream?

2. Hvilket interface bruges til at generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode springer de første `n` elementer over i en stream?