Stream.filter(...)

You can filter a stream using the Stream.filter(...) method:

Stream<T> filter(Predicate<? super T> predicate);

								

Here is a stream filtering example:

stream.filter(s -> !s.startsWith("n"));
								

The filter(...) method takes a Predicate functional interface as parameter. The Predicate interface takes a single parameter and returns a boolean primitive. If you look at the lambda expression above, you can see that it takes a single parameter s and returns a boolean -- the result of the !s.startsWith("n") method call.

When you call the filter(...) method on a Stream, the filter passed as parameter to the filter(...) method is stored internally. No filtering takes place yet (lazy processing).

The parameter passed to the filter(...) function determines what items in the stream should be processed, and which that should be excluded from the processing. If the Predicate.test(T t) method of the parameter passed to filter(...) returns true for an item, that means it should be processed. If false is returned, the item is not processed.

Stream.map(...)

It is possible to map the items in a collection to other objects using Stream.map(...) method:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

								 

In other words, for each item in the collection you create a new object based on that item. Here is a simple Java stream mapping example:

stream.map(s -> s.toUpperCase());
								 

This example maps all strings in the items collection to their uppercase equivalents.

NOTE: this example does not actually perform the mapping (all intermediate operations are lazy). It only configures the stream for mapping. Once one of the stream processing methods are invoked, the mapping will be performed.

Stream.distinct()

The Stream.distinct() method in stream API returns stream with distinct elements. Whether or not element is distinct is decided by equals() method of Object class.

Stream<T> distinct();

								

Here is a simple example:

List<String> list = Arrays.asList("aA","AA","Aa", "Aa", "AA");
long l = list.stream().distinct().count();
System.out.println("Number of distinct elements : " + l);

								

Output:

Number of distinct elements : 3
								

Stream.peek(...)

The Stream.peek(...) returns Stream itself after applying the action passed as Consumer object.

Stream<T> peek(Consumer<? super T> action)

								

The Stream.peek(...) is extremely useful during debugging. It allows you to peek into the stream before an action is encountered. Here is a simple example:

Stream<String> words = Stream.of("lower", "case", "text");
List<String> list = words
    .peek(s -> System.out.println(s))
    .map(s -> s.toUpperCase())
    .collect(Collectors.toList());
System.out.println(list);

								

Output:

lower
case
text
[LOWER, CASE, TEXT]
								

Stream.collect(...)

Stream.collect(...) is a terminal operation to transform the elements of the stream into a different kind of result, e.g. a java.util.List, java.util.Set or java.util.Map:

<R, A> R collect(Collector<? super T, A, R> collector);

								

Stream.collect(...) accepts a Collector interface which consists of several operations including: supplier(), accumulator(), a combiner(), finisher():

public interface Collector<T, A, R> {
    Supplier<A> supplier();

    BiConsumer<A, T> accumulator();

    BinaryOperator<A> combiner();

    Function<A, R> finisher();

    ...

}

								

Java 11 supports various built-in collectors via the java.util.stream.Collectors final class. So for the most common operations you do not have to implement a Collector yourself:

List<String> list = Arrays.asList("Java", "is", "not", "great");
List<String> filtered = list.stream()
    .filter(item -> item.startsWith("J"))
    .collect(Collectors.toList());
System.out.print(filtered.get(0));

								

This example creates a stream, adds a filter, and collects all object accepted by the filter in a java.util.List. The filter only accepts items (strings) which start with the character J. The resulting java.util.List thus contains all strings from the original list which starts with the character J. Output is:

Java
								

Stream.min(...) / Stream.max(...)

The Stream.min(...) and Stream.max(...) methods are stream processing terminal methods. Once these are called, the stream will be iterated, filtering and mapping applied, and the minimum or maximum value in the stream will be returned:

Optional<T> min(Comparator<? super T> comparator);

Optional<T> max(Comparator<? super T> comparator);

								

The Stream.min(...) and Stream.max(...) methods return an Optional instance which has a get() method, which you use to obtain the value. In case the Optional has no value the get() method will throw NoSuchElementException.

The Stream.min(...) and Stream.max(...) methods take a java.util.Comparator as parameter. The Comparator.comparing(...) method creates a Comparator based on the lambda expression passed to it. In fact, the comparing(...) method takes a Function which is a functional interface suited for lambda expressions. It takes one parameter and returns a value:

Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);

								

Stream.findAny()

The Stream.findAny() finds any element in the stream, which may be cheaper than findFirst() for some streams. This is a short circuit terminal operation. A short circuit terminal operation potentially allows processing of a stream to stop early without examining all the elements.

Optional<T> findAny();

								

Here is an example:

List<String> list = Arrays.asList("Java", "is", "not", "great");
Optional<String> result = list.stream()
    .filter(item -> item.contains("t"))
    .findAny();
System.out.print(result.get());

								

This example processes elements from collection one by one and gets the first element that contains character t, and then passes to findAny method. The findAny method immediately stops pipeline execution, so no further elements will be processed. The possible output is:

not
								

	It will most likely return 'not' but there is no guarantee for this. Printing 'great' also a possible option.

Stream.findFirst()

The method findFirst() provides the first element from the stream. The return value is an Optional, in case of an empty stream an empty optional.

Optional<T> findFirst();

								

It will return first element from stream and then will not process any further elements, as it is a short circuit terminal operation.

Stream.count()

The Stream.count() method simply returns the number of elements in the stream after filtering has been applied.

long count();
								

Here is an example:

List<String> list = Arrays.asList("Java", "is", "not", "great");
long l = list.stream()
    .filter(item -> item.startsWith("J"))
    .count();
System.out.print(l);

								

This example iterates the stream and keeps all elements that start with the character J, and then counts these elements. The count() method returns a long which is the count of elements in the stream after filetering it:

1
								

a source (which might be an array, a Collection, a generator function, an I/O channel, etc.)

zero or more intermediate operations (which transform a Stream into another Stream, such as filter(Predicate p))

a terminal operation (which produces a result or side-effect, such as count() or forEach(Consumer c))

It takes an input stream and produces an output stream using a mapping function.

The mapping function takes an element from the input stream and maps the element to a stream. The type of input element and the elements in the mapped stream may be different. This step produces a stream of streams. Suppose the input stream is a Stream<T> and the mapped stream is Stream<Stream<R>> where T and R may be the same or different.

Finally, it flattens the output stream (that is, a stream of streams) to produce a stream. That is, the Stream<Stream<R>> is flattened to Stream<R>.

The map(...) accepts a function that returns a mapped element and then the map(...) function returns a stream of such elements (1 to 1).

The flatMap accepts a function that returns streams of the mapped elements and then the flatMap finally returns a collective stream of all of the sub-streams that are created by the each execution of the passed function (1 to 0...n).