Cómo obtener Slice of a Stream en Java

Una secuencia es una secuencia de objetos que admite varios métodos que se pueden canalizar para producir el resultado deseado. Slice of a Stream significa una secuencia de elementos que existe en un límite específico, a partir de la secuencia original.

Ejemplos:

Entrada: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Salida: [15, 16, 17, 18, 19]
Explicación: La salida contiene una porción del flujo desde el índice 4 hasta 8.

Entrada: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Salida: [2, 3, 4]
Explicación: La salida contiene una porción de la transmisión del índice 1 al 3.

A continuación se muestran los métodos para eliminar valores nulos de una lista en Java:

1. Usando skip() y limit() : Stream API en Java proporciona el método skip() que se usa para descartar los otros elementos no requeridos de la secuencia. También proporciona la función limit() que se aplica para obtener la nueva secuencia con el índice especificado como límite, en el orden encontrado.

   Algoritmo :

   1. Obtener el Stream para ser cortado.
   2. Obtenga el índice Desde y Hasta para dividirlo de Stream como StartIndex y EndIndex
   3. Llame al método skip() para especificar la cantidad de elementos que se omitirán antes del índice inicial como skip(startIndex)
   4. Llame al método limit() para especificar la cantidad de elementos, de la secuencia, que deben limitarse como limit (endIndex – startIndex + 1)
   5. Devolver el flujo rebanado

   // Java program to get slice of a stream using // Stream skip() and limit() import java.util.*; import java.util.stream.Stream;    class GFG {        // Generic function to get Slice of a     // Stream from startIndex to endIndex     public static <T> Stream<T>     getSliceOfStream(Stream<T> stream, int startIndex,                                            int endIndex)     {         return stream             // specify the number of elements to skip             .skip(startIndex)                // specify the no. of elements the stream             // that should be limited             .limit(endIndex - startIndex + 1);     }     public static void main(String[] args)     {            // Create a new List with values 11 - 20         List<Integer> list = new ArrayList<>();         for (int i = 11; i <= 20; i++)             list.add(i);            // Create stream from list         Stream<Integer> intStream = list.stream();            // Print the stream         System.out.println("List: " + list);            // Get Slice of Stream         // containing of elements from the 4th index to 8th         Stream<Integer>             sliceOfIntStream = getSliceOfStream(intStream, 4, 8);            // Print the slice         System.out.println("\nSlice of Stream:");         sliceOfIntStream.forEach(System.out::println);     } }

   Producción:

   List: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
   
   Slice of Stream:
   15
   16
   17
   18
   19
   

2. Uso de recopiladores junto con skip() y limit() : en este método, el Stream se convierte en List y luego se usa una función de un recopilador para obtener una sublista de los elementos deseados y la identificación de la sublista se vuelve a convertir en un stream usando stream.collect(Collectors.collectingAndThen()) .

   Algoritmo :

   1. Obtener el Stream para ser cortado.
   2. Obtenga el índice Desde y Hasta para dividirlo de Stream como StartIndex y EndIndex
   3. Usando Collectors.collectingAndThen ,
   4. Convierta la transmisión en lista usando Collectors.toList()
   5. Obtenga la secuencia de la lista como list.stream()
   6. Llame al método skip() para especificar la cantidad de elementos que se omitirán antes del índice inicial como skip(startIndex)
   7. Llame al método limit() para especificar la cantidad de elementos, de la secuencia, que deben limitarse como limit (endIndex – startIndex + 1)
   8. Recopile el flujo de la lista dividida usando stream.collect()
   9. Devolver el flujo rebanado

   // Java program to get slice of a stream using // Collection skip() and limit() import java.util.*; import java.util.stream.*;    class GFG {        // Generic function to get Slice of a     // Stream from startIndex to endIndex     public static <T> Stream<T>     getSliceOfStream(Stream<T> stream, int startIndex, int endIndex)     {         return stream.collect(Collectors.collectingAndThen(                // 1st argument             // Convert the stream to list             Collectors.toList(),                // 2nd argument             list -> list.stream()                         // specify the number of elements to skip                         .skip(startIndex)                            // specify the no. of elements the stream                         // that should be limited                         .limit(endIndex - startIndex + 1)));     }     public static void main(String[] args)     {            // Create a new List with values 11 - 20         List<Integer> list = new ArrayList<>();         for (int i = 11; i <= 20; i++)             list.add(i);            // Create stream from list         Stream<Integer> intStream = list.stream();            // Print the stream         System.out.println("List: " + list);            // Get Slice of Stream         // containing of elements from the 4th index to 8th         Stream<Integer>             sliceOfIntStream = getSliceOfStream(intStream, 4, 8);            // Print the slice         System.out.println("\nSlice of Stream:");         sliceOfIntStream.forEach(System.out::println);     } }

   Producción:

   List: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
   
   Slice of Stream:
   15
   16
   17
   18
   19
   

3. Obtener una sublista : este método consiste en convertir una secuencia en una lista. Ahora esta lista se usa para obtener una subLista requerida de ella entre el índice especificado. Y finalmente, esta subLista se vuelve a convertir en Stream.

   Algoritmo :

   1. Obtener el Stream para ser cortado.
   2. Obtenga el índice Desde y Hasta para dividirlo de Stream como StartIndex y EndIndex
   3. Convierta la transmisión en lista usando Collectors.toList() y luego recójala usando stream.collect()
   4. Obtenga la subLista de la Lista recopilada con el índice de inicio y el índice final + 1 como límite usando subLista (índice de inicio, índice final + 1)
   5. Convierta la subLista de nuevo en flujo usando stream()
   6. Devolver el flujo rebanado

   // Java program to get slice of a stream by // fetching a sublist import java.util.*; import java.util.stream.*;    class GFG {        // Generic function to get Slice of a     // Stream from startIndex to endIndex     public static <T> Stream<T>     getSliceOfStream(Stream<T> stream, int startIndex, int endIndex)     {         return stream             // Convert the stream to list             .collect(Collectors.toList())                // Fetch the subList between the specified index             .subList(startIndex, endIndex + 1)                // Convert the subList to stream             .stream();     }        public static void main(String[] args)     {            // Create a new List with values 11 - 20         List<Integer> list = new ArrayList<>();         for (int i = 11; i <= 20; i++)             list.add(i);            // Create stream from list         Stream<Integer> intStream = list.stream();            // Print the stream         System.out.println("List: " + list);            // Get Slice of Stream         // containing of elements from the 4th index to 8th         Stream<Integer>             sliceOfIntStream = getSliceOfStream(intStream, 4, 8);            // Print the slice         System.out.println("\nSlice of Stream:");         sliceOfIntStream.forEach(System.out::println);     } }

   Producción:

   List: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
   
   Slice of Stream:
   15
   16
   17
   18
   19