Java 8 Stream API: Introduction, Methods, Advantages, & Examples

What is Stream API in Java: Introduction to Java 8 Stream API

Java 8 introduced the Stream API, a powerful feature added to the Collections API that allows developers to process sequences of elements in a functional programming style. Streams represent a sequence of elements and support various operations like filter, sort, map, and collect. These operations can be combined to form a stream pipeline, making data querying and manipulation more efficient, as shown in the diagram below:

How Java Streams Work: Simplified Example

Think of Java Streams as a sequence of objects that flow through a pipeline. You can control how many elements enter the pipeline, what actions are performed inside it, and how they are collected at the end. This functionality is essential for optimizing data processing and is ideal for tasks like Java parallel streams, which improve performance when working with large datasets.

Example of Java Streams in Action:

We can obtain a stream from a collection using the .stream() method. For instance, if we have a dropdown list of languages in a header section and want to print the list using both a for loop and the Stream API, here's how we would do it:

List<String> languages = new ArrayList<>();
languages.add("English");
languages.add("German");
languages.add("French");
 

Using a For Loop:

for (String language : languages) {
   System.out.println(language);
}
 

Using the Stream API:

languages.stream().forEach(System.out::println);

In this example, we obtain the stream from the languages list and apply the forEach() method to perform an action on each element. This is one of the simplest uses of Java Streams for functional-style programming.

Key Operations with Java Streams

Here are some core Stream API methods that can be used for various data processing tasks.

1. stream.filter(): Filtering Elements Based on Conditions

The filter() method is essential for processing streams. For instance, to filter out languages starting with the letter 'E', you can do the following:

languages.stream()
        .filter(item -> item.startsWith("E"))
        .forEach(System.out::println);

The filter() method takes a predicate, which is a lambda expression or functional interface, that determines which elements should be included in the stream.

2. stream.sort(): Sorting Data in Streams

Sorting the stream elements is just as easy:

languages.stream()
        .sorted()
        .forEach(System.out::println);

The sorted() method is often used in conjunction with Java Stream sorting for handling operations like ordering elements alphabetically or by custom criteria.

3. stream.map(): Transforming Elements of the Stream

The map() method is used to transform the elements of a stream. For example, if we want to convert all language names to uppercase:

languages.stream()
        .map(item -> item.toUpperCase())
        .forEach(System.out::println);

Java Stream mapping allows us to modify each element in the stream before collecting or displaying it.

4. stream.collect(): Collecting Data into Collections

To collect the processed elements back into a collection, we use the collect() method. For instance:

List<String> upperCaseLanguages = languages.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());
System.out.println(upperCaseLanguages);

The collect() method is one of the most commonly used methods in Java Streams for processing and accumulating data.

Advanced Java Stream Operations

stream.min() & max(): Finding Minimum and Maximum Elements

Java Streams offer the ability to compute the minimum and maximum values of the stream using min() and max() methods. For instance:

Integer maximum = Stream.of(10, 13, 4, 9, 2, 100)
                       .max(Comparator.comparing(Integer::valueOf))
                       .get();
Integer minimum = Stream.of(10, 13, 4, 9, 2, 100)
                       .min(Comparator.comparing(Integer::valueOf))
                       .get();
System.out.println("Max number is: " + maximum);
System.out.println("Min number is: " + minimum);

These methods are great for finding extreme values in collections, and they can be used with Java Streams for numeric data, strings, and more.

stream.count(): Counting Elements in a Stream

The count() method helps to get the number of elements in the stream that match a certain condition. Here's how we count the languages starting with 'G':

long count = languages.stream()
                     .filter(item -> item.startsWith("G"))
                     .count();

This operation is commonly used in situations where you need a count of elements after filtering or mapping them.

Java Stream API in Selenium WebDriver: Practical Example

Example: Filtering and Counting Web Elements

In Selenium WebDriver, the Stream API can be used to process web elements. For example, you can count the number of working links in a page:

List<WebElement> links = driver.findElements(By.tagName("a"));
long workingLinks = links.stream()
                        .filter(link -> link.getAttribute("href") != null)
                        .count();
System.out.println("Working link count: " + workingLinks);

This is a perfect example of using stream.filter() and stream.count() for processing collections of elements in Selenium tests.

Advantages of Java 8 Stream API

The Stream API offers numerous benefits, including:

1. Functional Programming: It allows developers to use lambda expressions and function interfaces, making the code more concise and readable.
2. Non-Mutability: Streams don't alter the source collections, ensuring that the original data is kept intact.
3. Parallel Processing: By utilizing parallel streams in Java, you can leverage multi-core processors to process large datasets more efficiently.
4. Readable and Efficient Code: Java Streams allow you to write more functional-style code that is easier to read and maintain.

Key Takeaways:

 1. Stream API simplifies working with data structures like lists, sets, and arrays.

 2. Functional programming with lambda expressions enhances the expressiveness of Java code.

 3. Advanced operations like filter, map, and reduce help to process data efficiently.

 4. Java Streams can easily be integrated into Selenium WebDriver to handle web elements more efficiently.

Conclusion:

By mastering the Java Stream API, developers can significantly enhance the readability and performance of their code. It allows for elegant solutions to complex problems, especially when working with large datasets or manipulating web elements in Selenium WebDriver. The functional programming paradigm in Java 8 improves both performance and maintainability, making it an essential tool for modern Java developers.

Streams are also helpful in working with the list of Web Elements, where we can easily collect & filter data with a stream.