Aprende Restringir y Omitir Elementos con los Métodos limit() y skip()

La API de Stream de Java ofrece métodos convenientes para trabajar con colecciones de datos. Dos métodos útiles, limit() y skip(), permiten controlar cuántos elementos se procesan en un stream o omitir una cierta cantidad de elementos, lo cual puede ser útil para optimizar el rendimiento al manejar conjuntos de datos grandes.

¿Qué son estos métodos?

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

En este ejemplo, se utiliza limit(10) para restringir el stream a los primeros 10 elementos, asegurando que solo esos elementos sean procesados.

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

Aquí, se utiliza skip(5) para ignorar los primeros cinco elementos y comenzar el procesamiento a partir del sexto elemento.

Ejemplo del mundo real

Imagina que trabajas en una fábrica con una lista de 50 piezas que necesitan inspección. Solo necesitas revisar las primeras 10 piezas mientras otro especialista se encarga del resto. En este caso, puedes usar limit(10).

Si las primeras 20 piezas ya han sido inspeccionadas y necesitas comenzar desde la pieza 21, puedes usar skip(20).

Ahora, vamos a implementar este escenario en código.

Aplicación práctica

En una fábrica, necesitas procesar piezas. Tienes una lista de 50 piezas y necesitas omitir las primeras 20, luego procesar las siguientes 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 + "'}";
    }
}

En este código, se utiliza un Supplier para crear dinámicamente objetos Part. La biblioteca UUID ayuda a generar identificadores únicos para cada parte.

Mediante Stream.generate(partSupplier), que recibe nuestro Supplier, se crea un stream de partes que sigue generando elementos hasta que se limita con limit(50).

Luego, skip(20) asegura que se ignoren las primeras 20 partes, mientras que limit(10) procesa solo las siguientes 10 partes.

Este enfoque permite una generación y procesamiento de datos eficiente sin necesidad de almacenar toda la lista en memoria.

1. ¿Qué hace el método `limit(n)` en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con `Stream.generate()`?

3. ¿Qué método omite los primeros `n` elementos en un stream?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 9

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Awesome!

Completion rate improved to 2.33

Desliza para mostrar el menú

¿Qué son estos métodos?

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

En este ejemplo, se utiliza limit(10) para restringir el stream a los primeros 10 elementos, asegurando que solo esos elementos sean procesados.

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

Aquí, se utiliza skip(5) para ignorar los primeros cinco elementos y comenzar el procesamiento a partir del sexto elemento.

Ejemplo del mundo real

Si las primeras 20 piezas ya han sido inspeccionadas y necesitas comenzar desde la pieza 21, puedes usar skip(20).

Ahora, vamos a implementar este escenario en código.

Aplicación práctica

En una fábrica, necesitas procesar piezas. Tienes una lista de 50 piezas y necesitas omitir las primeras 20, luego procesar las siguientes 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 + "'}";
    }
}

En este código, se utiliza un Supplier para crear dinámicamente objetos Part. La biblioteca UUID ayuda a generar identificadores únicos para cada parte.

Mediante Stream.generate(partSupplier), que recibe nuestro Supplier, se crea un stream de partes que sigue generando elementos hasta que se limita con limit(50).

Luego, skip(20) asegura que se ignoren las primeras 20 partes, mientras que limit(10) procesa solo las siguientes 10 partes.

Este enfoque permite una generación y procesamiento de datos eficiente sin necesidad de almacenar toda la lista en memoria.

1. ¿Qué hace el método `limit(n)` en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con `Stream.generate()`?

3. ¿Qué método omite los primeros `n` elementos en un stream?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 9

Restringir y Omitir Elementos con los Métodos limit() y skip()

¿Qué son estos métodos?

Ejemplo del mundo real

Aplicación práctica

1. ¿Qué hace el método limit(n) en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con Stream.generate()?

3. ¿Qué método omite los primeros n elementos en un stream?

Awesome!

Restringir y Omitir Elementos con los Métodos limit() y skip()

¿Qué son estos métodos?

Ejemplo del mundo real

Aplicación práctica

1. ¿Qué hace el método limit(n) en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con Stream.generate()?

3. ¿Qué método omite los primeros n elementos en un stream?

1. ¿Qué hace el método `limit(n)` en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con `Stream.generate()`?

3. ¿Qué método omite los primeros `n` elementos en un stream?

1. ¿Qué hace el método `limit(n)` en un stream?

2. ¿Qué interfaz se utiliza para generar elementos en un stream con `Stream.generate()`?

3. ¿Qué método omite los primeros `n` elementos en un stream?