1. Overview
Java Stream API provides various methods to operate and work with a sequence of elements. However, it’s not easy if we want to process only part of the stream, e.g., every N-th element. This might be useful if we’re processing a stream of raw data representing a CSV file or database table and would like to process only specific columns.
We’ll address two kinds of streams: finite and infinite. The first case can be resolved by converting a Stream into a List, which allows indexing. On the other side, infinite streams would require a different approach. In this tutorial, we’ll learn how to address this challenge using various techniques.
2. Tests Setup
We’ll use parametrized tests to check the correctness of our solutions. There’ll be a couple of cases with respective N-th elements and expected results:
Arguments.of(
Stream.of("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"),
List.of("Wednesday", "Saturday"), 3),
Arguments.of(
Stream.of("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"),
List.of("Friday"), 5),
Arguments.of(
Stream.of("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"),
List.of("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"), 1)
Now, we can dive into different methods of processing the N-th element from a stream.
3. Using filter()
In the first approach, we can create a separate stream containing only the indexes of the elements we would like to process. We can use a filter(Predicate) to create such an array:
void givenListSkipNthElementInListWithFilterTestShouldFilterNthElement(Stream<String> input, List<String> expected, int n) {
final List<String> sourceList = input.collect(Collectors.toList());
final List<String> actual = IntStream.range(0, sourceList.size())
.filter(s -> (s + 1) % n == 0)
.mapToObj(sourceList::get)
.collect(Collectors.toList());
assertEquals(expected, actual);
}
This approach will work if we want to operate on a data structure that allows indexed accesses, such as a List. The needed elements can be collected to a new List or processed with forEach(Consumer).
4. Using iterate()
This approach is similar to the previous one and requires a data structure with indexed accesses. However, instead of filtering out indexes we don’t need, we’ll generate only the indexes we would like to use in the beginning:
void givenListSkipNthElementInListWithIterateTestShouldFilterNthElement(Stream<String> input, List<String> expected, int n) {
final List<String> sourceList = input.collect(Collectors.toList());
int limit = sourceList.size() / n;
final List<String> actual = IntStream.iterate(n - 1, i -> (i + n))
.limit(limit)
.mapToObj(sourceList::get)
.collect(Collectors.toList());
assertEquals(expected, actual);
}
In this case, we’re using IntStream.iterate(int, IntUnaryOperator), which allows us to create an integer sequence with n step.
5. Using subList()
This approach uses Stream.iterate and is similar to the previous one, but it creates a stream of Lists, each starting at the nk-th index:
void givenListSkipNthElementInListWithSublistTestShouldFilterNthElement(Stream<String> input, List<String> expected, int n) {
final List<String> sourceList = input.collect(Collectors.toList());
int limit = sourceList.size() / n;
final List<String> actual = Stream.iterate(sourceList, s -> s.subList(n, s.size()))
.limit(limit)
.map(s -> s.get(n - 1))
.collect(Collectors.toList());
assertEquals(expected, actual);
}
We should take the first element of each of these Lists to get the needed result.
6. Using a Custom Collector
As a more advanced and transparent solution, we can implement a custom Collector that collects only the needed elements:
class SkippingCollector {
private static final BinaryOperator<SkippingCollector> IGNORE_COMBINE = (a, b) -> a;
private final int skip;
private final List<String> list = new ArrayList<>();
private int currentIndex = 0;
private SkippingCollector(int skip) {
this.skip = skip;
}
private void accept(String item) {
int index = ++currentIndex % skip;
if (index == 0) {
list.add(item);
}
}
private List<String> getResult() {
return list;
}
public static Collector<String, SkippingCollector, List<String>> collector(int skip) {
return Collector.of(() -> new SkippingCollector(skip),
SkippingCollector::accept,
IGNORE_COMBINE,
SkippingCollector::getResult);
}
}
This approach is more complex and requires some coding. At the same time, this solution doesn’t allow parallelization and technically may fail even on sequential streams because combining is an implementation detail that might change in future releases:
public static List<String> skipNthElementInStreamWithCollector(Stream<String> sourceStream, int n) {
return sourceStream.collect(SkippingCollector.collector(n));
}
However, it’s possible to use Spliterators to make this approach work for parallel streams, but it should have a good reason for this.
7. Simple Loop
All the previous solutions would work, but overall, they’re unnecessarily complex and often misguiding. The best way to resolve the problem is often with the simplest implementation possible. This is how we can use a for loop to achieve the same:
void givenListSkipNthElementInListWithForTestShouldFilterNthElement(Stream<String> input, List<String> expected, int n) {
final List<String> sourceList = input.collect(Collectors.toList());
List<String> result = new ArrayList<>();
for (int i = n - 1; i < sourceList.size(); i += n) {
result.add(sourceList.get(i));
}
final List<String> actual = result;
assertEquals(expected, actual);
}
However, sometimes, we need to work with a Stream directly, and this won’t allow us to access elements directly by their indexes. In this case, we can use an Iterator with a while loop:
void givenListSkipNthElementInStreamWithIteratorTestShouldFilterNthElement(Stream<String> input, List<String> expected, int n) {
List<String> result = new ArrayList<>();
final Iterator<String> iterator = input.iterator();
int count = 0;
while (iterator.hasNext()) {
if (count % n == n - 1) {
result.add(iterator.next());
} else {
iterator.next();
}
++count;
}
final List<String> actual = result;
assertEquals(expected, actual);
}
These solutions are cleaner and more straightforward to understand while resolving the same problem.
8. Conclusion
Java Stream API is a powerful tool that helps to make the code more declarative and readable. Additionally, streams can achieve a better performance by utilizing parametrization. However, the desire to use streams everywhere might not be the best way to approach this API.
Although mental gymnastics of applying stream operation in the cases where they’re not ideally suitable might be fun, it might also result in “clever code.” Often, the simplest structure, like loops, can achieve the same result with less and more understandable code.
As always, all the code used in this article is available over on GitHub.
