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:
- 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:
- Get the Stream to be sliced.
- Get the From and To index to be sliced from Stream as StartIndex and EndIndex
- Call skip() method to specify the number of elements to be skipped before the starting index as skip(startIndex)
- Call limit() method to specify the number of elements, from the stream, that should be limited as limit(endIndex – startIndex + 1)
- Return the Sliced Stream
import java.util.*;
import java.util.stream.Stream;
class GFG {
public static <T> Stream<T>
getSliceOfStream(Stream<T> stream, int startIndex,
int endIndex)
{
return stream
.skip(startIndex)
.limit(endIndex - startIndex + 1 );
}
public static void main(String[] args)
{
List<Integer> list = new ArrayList<>();
for ( int i = 11 ; i <= 20 ; i++)
list.add(i);
Stream<Integer> intStream = list.stream();
System.out.println( "List: " + list);
Stream<Integer>
sliceOfIntStream = getSliceOfStream(intStream, 4 , 8 );
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
- 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:
- Get the Stream to be sliced.
- Get the From and To index to be sliced from Stream as StartIndex and EndIndex
- Using Collectors.collectingAndThen,
- Convert the Stream to List using Collectors.toList()
- Obtain the Stream from the List as list.stream()
- Call skip() method to specify the number of elements to be skipped before the starting index as skip(startIndex)
- Call limit() method to specify the number of elements, from the stream, that should be limited as limit(endIndex – startIndex + 1)
- Collect the sliced list stream using stream.collect()
- Return the Sliced Stream
import java.util.*;
import java.util.stream.*;
class GFG {
public static <T> Stream<T>
getSliceOfStream(Stream<T> stream, int startIndex, int endIndex)
{
return stream.collect(Collectors.collectingAndThen(
Collectors.toList(),
list -> list.stream()
.skip(startIndex)
.limit(endIndex - startIndex + 1 )));
}
public static void main(String[] args)
{
List<Integer> list = new ArrayList<>();
for ( int i = 11 ; i <= 20 ; i++)
list.add(i);
Stream<Integer> intStream = list.stream();
System.out.println( "List: " + list);
Stream<Integer>
sliceOfIntStream = getSliceOfStream(intStream, 4 , 8 );
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
- 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:
- Get the Stream to be sliced.
- Get the From and To index to be sliced from Stream as StartIndex and EndIndex
- Convert the Stream to List using Collectors.toList() and then collect it using stream.collect()
- Fetch the subList from the collected List with the startIndex and endIndex+1 as the limit using subList(startIndex, endIndex + 1)
- Convert the subList back to stream using stream()
- Return the Sliced Stream
import java.util.*;
import java.util.stream.*;
class GFG {
public static <T> Stream<T>
getSliceOfStream(Stream<T> stream, int startIndex, int endIndex)
{
return stream
.collect(Collectors.toList())
.subList(startIndex, endIndex + 1 )
.stream();
}
public static void main(String[] args)
{
List<Integer> list = new ArrayList<>();
for ( int i = 11 ; i <= 20 ; i++)
list.add(i);
Stream<Integer> intStream = list.stream();
System.out.println( "List: " + list);
Stream<Integer>
sliceOfIntStream = getSliceOfStream(intStream, 4 , 8 );
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
Last Updated :
11 Dec, 2018
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...