Lære Begrensning og Hopping Over Elementer med Limit()- og Skip()-Metodene

Java Stream API tilbyr praktiske metoder for å arbeide med datasamlinger. To nyttige metoder, limit() og skip(), gjør det mulig å kontrollere hvor mange elementer som behandles i en strøm eller hoppe over et visst antall elementer. Dette kan være nyttig for å optimalisere ytelsen ved håndtering av store datasett.

Hva er disse metodene?

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 eksempelet brukes limit(10) for å begrense strømmen til de første 10 elementene, slik at kun disse elementene blir 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 brukes skip(5) for å ignorere de fem første elementene og starte behandlingen fra det sjette elementet og videre.

Virkelig eksempelsituasjon

Tenk deg at du jobber på en fabrikk med en liste over 50 deler som skal inspiseres. Du trenger kun å kontrollere de første 10 delene, mens en annen spesialist håndterer resten. I dette tilfellet kan du bruke limit(10).

Hvis de første 20 delene allerede er inspisert og du må starte fra del 21, kan du bruke skip(20).

La oss nå implementere dette scenariet i kode.

Praktisk anvendelse

På en fabrikk må du behandle deler. Du har en liste over 50 deler og må hoppe over de første 20, deretter behandle de neste 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 koden brukes en Supplier for å dynamisk opprette Part-objekter. UUID-biblioteket hjelper til med å generere unike identifikatorer for hver del.

Ved å bruke Stream.generate(partSupplier), som tar vår Supplier, opprettes en stream av deler som fortsetter å generere elementer til du begrenser den med limit(50).

Deretter sørger skip(20) for at de første 20 delene ignoreres, mens limit(10) kun behandler de neste 10 delene.

Denne tilnærmingen gir effektiv datagenerering og prosessering uten behov for å lagre hele listen i minnet.

1. Hva gjør metoden `limit(n)` i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode hopper over de første `n` elementene i en strøm?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 9

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Awesome!

Completion rate improved to 2.33

Sveip for å vise menyen

Hva er disse metodene?

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 eksempelet brukes limit(10) for å begrense strømmen til de første 10 elementene, slik at kun disse elementene blir 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 brukes skip(5) for å ignorere de fem første elementene og starte behandlingen fra det sjette elementet og videre.

Virkelig eksempelsituasjon

Hvis de første 20 delene allerede er inspisert og du må starte fra del 21, kan du bruke skip(20).

La oss nå implementere dette scenariet i kode.

Praktisk anvendelse

På en fabrikk må du behandle deler. Du har en liste over 50 deler og må hoppe over de første 20, deretter behandle de neste 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 koden brukes en Supplier for å dynamisk opprette Part-objekter. UUID-biblioteket hjelper til med å generere unike identifikatorer for hver del.

Ved å bruke Stream.generate(partSupplier), som tar vår Supplier, opprettes en stream av deler som fortsetter å generere elementer til du begrenser den med limit(50).

Deretter sørger skip(20) for at de første 20 delene ignoreres, mens limit(10) kun behandler de neste 10 delene.

Denne tilnærmingen gir effektiv datagenerering og prosessering uten behov for å lagre hele listen i minnet.

1. Hva gjør metoden `limit(n)` i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode hopper over de første `n` elementene i en strøm?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 2. Kapittel 9

Begrensning og Hopping Over Elementer med Limit()- og Skip()-Metodene

Hva er disse metodene?

Virkelig eksempelsituasjon

Praktisk anvendelse

1. Hva gjør metoden limit(n) i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med Stream.generate()?

3. Hvilken metode hopper over de første n elementene i en strøm?

Awesome!

Begrensning og Hopping Over Elementer med Limit()- og Skip()-Metodene

Hva er disse metodene?

Virkelig eksempelsituasjon

Praktisk anvendelse

1. Hva gjør metoden limit(n) i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med Stream.generate()?

3. Hvilken metode hopper over de første n elementene i en strøm?

1. Hva gjør metoden `limit(n)` i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode hopper over de første `n` elementene i en strøm?

1. Hva gjør metoden `limit(n)` i en stream?

2. Hvilket grensesnitt brukes for å generere elementer i en stream med `Stream.generate()`?

3. Hvilken metode hopper over de første `n` elementene i en strøm?