Apprendre Restriction et Saut d’Éléments avec les Méthodes limit() et skip() | Opérations Intermédiaires dans l'API Stream

L'API Stream de Java propose des méthodes pratiques pour manipuler des collections de données. Deux méthodes utiles, limit() et skip(), permettent de contrôler le nombre d'éléments traités dans un flux ou d'en ignorer un certain nombre, ce qui peut être utile pour optimiser les performances lors du traitement de grandes quantités de données.

Que sont ces méthodes ?

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

Dans cet exemple, utilisation de limit(10) pour restreindre le flux aux 10 premiers éléments, garantissant que seuls ces éléments sont traités.

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

Ici, utilisation de skip(5) pour ignorer les cinq premiers éléments et commencer le traitement à partir du sixième élément.

Exemple concret

Imaginez que vous travaillez dans une usine avec une liste de 50 pièces à inspecter. Vous devez uniquement vérifier les 10 premières pièces tandis qu'un autre spécialiste s'occupe du reste. Dans ce cas, vous pouvez utiliser limit(10).

Si les 20 premières pièces ont déjà été inspectées et que vous devez commencer à partir de la pièce 21, vous pouvez utiliser skip(20).

Voyons maintenant comment implémenter ce scénario en code.

Application pratique

Dans une usine, il est nécessaire de traiter des pièces. Vous disposez d'une liste de 50 pièces et devez ignorer les 20 premières, puis traiter les 10 suivantes.

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

Dans ce code, un Supplier est utilisé pour créer dynamiquement des objets Part. La bibliothèque UUID permet de générer des identifiants uniques pour chaque pièce.

En utilisant Stream.generate(partSupplier), qui prend notre Supplier, un flux de pièces est créé, générant continuellement des éléments jusqu'à ce qu'il soit limité par limit(50).

Ensuite, skip(20) permet d'ignorer les 20 premières pièces, tandis que limit(10) traite uniquement les 10 pièces suivantes.

Cette méthode permet une génération et un traitement efficaces des données sans avoir à stocker toute la liste en mémoire.

1. Que fait la méthode `limit(n)` dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec `Stream.generate()` ?

3. Quelle méthode ignore les `n` premiers éléments d'un flux ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 9

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 2.33

Glissez pour afficher le menu

Que sont ces méthodes ?

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

Dans cet exemple, utilisation de limit(10) pour restreindre le flux aux 10 premiers éléments, garantissant que seuls ces éléments sont traités.

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

Ici, utilisation de skip(5) pour ignorer les cinq premiers éléments et commencer le traitement à partir du sixième élément.

Exemple concret

Si les 20 premières pièces ont déjà été inspectées et que vous devez commencer à partir de la pièce 21, vous pouvez utiliser skip(20).

Voyons maintenant comment implémenter ce scénario en code.

Application pratique

Dans une usine, il est nécessaire de traiter des pièces. Vous disposez d'une liste de 50 pièces et devez ignorer les 20 premières, puis traiter les 10 suivantes.

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

Dans ce code, un Supplier est utilisé pour créer dynamiquement des objets Part. La bibliothèque UUID permet de générer des identifiants uniques pour chaque pièce.

Ensuite, skip(20) permet d'ignorer les 20 premières pièces, tandis que limit(10) traite uniquement les 10 pièces suivantes.

Cette méthode permet une génération et un traitement efficaces des données sans avoir à stocker toute la liste en mémoire.

1. Que fait la méthode `limit(n)` dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec `Stream.generate()` ?

3. Quelle méthode ignore les `n` premiers éléments d'un flux ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 9

Restriction et Saut d’Éléments avec les Méthodes limit() et skip()

Que sont ces méthodes ?

Exemple concret

Application pratique

1. Que fait la méthode limit(n) dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec Stream.generate() ?

3. Quelle méthode ignore les n premiers éléments d'un flux ?

Awesome!

Restriction et Saut d’Éléments avec les Méthodes limit() et skip()

Que sont ces méthodes ?

Exemple concret

Application pratique

1. Que fait la méthode limit(n) dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec Stream.generate() ?

3. Quelle méthode ignore les n premiers éléments d'un flux ?

1. Que fait la méthode `limit(n)` dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec `Stream.generate()` ?

3. Quelle méthode ignore les `n` premiers éléments d'un flux ?

1. Que fait la méthode `limit(n)` dans un flux ?

2. Quelle interface est utilisée pour générer des éléments dans un flux avec `Stream.generate()` ?

3. Quelle méthode ignore les `n` premiers éléments d'un flux ?