TakeWhile & DropWhile in Java 9 Streams with Examples
One of the most significant features introduced in Java 8 was Streams API. Since then, as Streams is on demand, later releases also focuses on improving or adding the news features in the same. That's where 2 more Stream operations came into picture with the release of Java 9. Here are we going to see two more collections that have been added as part of the Java 9 release i.e DropWhile & TakeWhile.
In this tutorial, we are going to cover below topics: What is takeWhile & dropWhile operations in Streams? How to implement it with example?
1. What is takeWhile & dropWhile operations in Streams?
takeWhile takeWhile expects a predicate and returns a new stream consisting only of the elements that match the given predicate. But, it classifying among three different cases. Let's understand all of them, If the stream is Ordered: It returns a stream consisting of the longest prefix of elements taken from this stream that match the given predicate. If this stream is ordered then the longest prefix is a contiguous sequence of elements of this stream that match the given predicate. The first element of the sequence is the first element of this stream, and the element immediately following the last element of the sequence does not match the given predicate. Stream.of(1, 3, 5, 7, 9, 13, 16, 17, 19) .takeWhile(e -> e % 2 != 0) .forEach(e -> System.out.println(e)); // Output: // 1 // 3 // 5 // 7 // 9 // 13 If you notice above, 17 & 19 are also matching the predicate but because 16 is not matching, therefore, the returning stream won't consider 17 and 19 and just cut off at the failing element. If the stream is Un-Ordered: It returns a stream consisting of a subset of elements taken from this stream that match the given predicate. If this stream is unordered, and some (but not all) elements of this stream match the given predicate, then the behavior of this operation is nondeterministic; it is free to take any subset of matching elements(which includes the empty set). Set numbers = Set.of(1,3,5,2,7); numbers.stream() .takeWhile(e -> e % 2 != 0) .forEach(e -> System.out.println(e)); // Now, you can see different out all the time Or even there can be an empty set If the stream is independent of whether ordered or un0rdered (Matching all elements OR Matching none of the element): If all elements of this stream match the given predicate then this operation takes all elements means the output is same as input, or if no elements of the stream match the given predicate then no elements are taken then the output is an empty steam. Set numbers = Set.of(25, 75, 100, 125, 150); numbers.stream() .takeWhile(n -> n % 5 == 0) .forEach(e -> System.out.println(e)); // Your can always see the same result 75 125 100 150 25 as input But the order could be non deterministic Set numbers = Set.of(25, 75, 100, 125, 150); numbers.Stream .takeWhile(n -> n % 5 != 0) .forEach(e -> System.out.println(e)); // It will print out nothing
dropWhile dropWhile is the opposite of takeWhile. dropWhile drops the elements which is matching to the predicate instead of taking them as takeWhile. And, whenever it reaches to the element which does not match the predicate, it includes the remaining elements in the returned stream. Stream.of(1,3,5,7,9,13,16,17,19) .dropWhile(e -> e % 2 != 0) .forEach(e -> System.out.println(e)); // Output: // 16 // 17 // 19
2. takeWhile & dropWhile implementation example
import java.util.*; public class TakeWhile_Java9_Example { public static void main(String args) { List OrderedList = Arrays.asList(1, 3, 5, 7, 9, 13, 16, 17, 19); Set UnorderedList = Set.of(1, 3, 5, 2, 7); Set IndependentList = Set.of(25, 75, 100, 125, 150); //takeWhile //Ordered Stream Example System.out.println("takeWhile - Ordered"); OrderedList.stream() .takeWhile(e -> e % 2 != 0) .forEach(e -> System.out.println(e)); //Unordered Stream Example System.out.println("\ntakeWhile - Unordered"); UnorderedList.stream() .takeWhile(e -> e % 2 != 0) .forEach(System.out::println); //Independent Stream Example (When all elements are matching) System.out.println("\ntakeWhile - Independent (all elements matching)"); IndependentList.stream() .takeWhile(e -> e % 5 == 0) .forEach(System.out::println); //Independent Stream Example (When none of the element is matching) System.out.println("\ntakeWhile - Independent (none of the element matching)"); IndependentList.stream() .takeWhile(e -> e .forEach(System.out::println); //dropWhile //Ordered Stream Example System.out.println("\ndropWhile - Ordered"); OrderedList.stream() .dropWhile(e -> e % 2 != 0) .forEach(e -> System.out.println(e)); } } Output: takeWhile - Ordered 1 3 5 7 9 13 takeWhile - Unordered 7 5 3 takeWhile - Independent (all elements matching) 125 75 25 150 100 takeWhile - Independent (none of the element matching) dropWhile - Ordered 16 17 19 takeWhile & dropWhile are truly useful addition as part of Streams in Java 9 and can serve variety of purposes. I hope above examples could help you to get better idea on how to implement it. Do you like this Post? – then check my other helpful posts: Passing Function as a Parameter in another Method in Java 8 Collection sorting using Lambda in Java 8 Generate Prime numbers in Java 8 Other Useful References: java.util.stream by Oracle Java 8 Stream by Baeldung Read the full article