How to get Slice of a Stream in Java

A stream is a sequence of objects that supports various methods which can be pipelined to produce the desired result. Slice of a Stream means a stream of elements that exists in a specified limit, from the original stream.

Examples:

Input: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
Output: [15, 16, 17, 18, 19]
Explanation: The output contains a slice of the stream from index 4 to 8.

Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Output: [2, 3, 4]
Explanation: The output contains a slice of the stream from index 1 to 3.

Below are the methods to remove nulls from a List in Java:

1. Using skip() and limit(): Stream API in Java provides skip() method which is used to discard the other non-required elements from the stream. It also provides limit() function which is applied to fetch the new stream with the specified index as limit, in the encountered order.

   Algorithm:

   1. Get the Stream to be sliced.
   2. Get the From and To index to be sliced from Stream as StartIndex and EndIndex
   3. Call skip() method to specify the number of elements to be skipped before the starting index as skip(startIndex)
   4. Call limit() method to specify the number of elements, from the stream, that should be limited as limit(endIndex – startIndex + 1)
   5. Return the Sliced Stream

   
   

   
   
   

   // 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);     } }
   Output:

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

2. Using Collectors along with skip() and limit(): In this method, the Stream is converted to List and then a function of a collector to get sub-list of desired elements is used and the sub-list id converted back to a stream using stream.collect(Collectors.collectingAndThen()).

   Algorithm:

   1. Get the Stream to be sliced.
   2. Get the From and To index to be sliced from Stream as StartIndex and EndIndex
   3. Using Collectors.collectingAndThen,
   4. Convert the Stream to List using Collectors.toList()
   5. Obtain the Stream from the List as list.stream()
   6. Call skip() method to specify the number of elements to be skipped before the starting index as skip(startIndex)
   7. Call limit() method to specify the number of elements, from the stream, that should be limited as limit(endIndex – startIndex + 1)
   8. Collect the sliced list stream using stream.collect()
   9. Return the Sliced Stream

   
   

   
   
   

   // 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);     } }
   Output:

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

3. Fetching a SubList: This method involves converting a Stream into a List. Now this list is used to fetch a required subList from it between the specified index. And finally, this subList is converted back to Stream.

   Algorithm:

   1. Get the Stream to be sliced.
   2. Get the From and To index to be sliced from Stream as StartIndex and EndIndex
   3. Convert the Stream to List using Collectors.toList() and then collect it using stream.collect()
   4. Fetch the subList from the collected List with the startIndex and endIndex+1 as the limit using subList(startIndex, endIndex + 1)
   5. Convert the subList back to stream using stream()
   6. Return the Sliced Stream

   
   

   
   
   

   // 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);     } }
   Output:

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