Java 8 Stream - W3spoint

Java 8 introduced the concept of streams, which are a sequence of elements that can be processed in parallel or sequentially. Streams allow you to perform various operations on a collection of data, such as filtering, mapping, and sorting, in a concise and functional manner.

To create a stream in Java 8, you can call the stream() method on a collection, such as a List, Set, or Map. For example, the following code creates a stream of integers:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> numberStream = numbers.stream();

Once you have a stream, you can perform various operations on it. There are two types of operations: intermediate operations, which return a new stream, and terminal operations, which produce a result or a side effect.

Intermediate operations include:

filter(Predicate<T> predicate): filters the stream based on a given condition.
map(Function<T, R> mapper): maps each element in the stream to a new value using a given function.
flatMap(Function<T, Stream<R>> mapper): maps each element in the stream to a new stream and flattens the result into a single stream.
distinct(): removes duplicate elements from the stream.
sorted(): sorts the stream in natural order.
peek(Consumer<T> action): applies a given action to each element in the stream without modifying the stream.

Terminal operations include:

forEach(Consumer<T> action): applies a given action to each element in the stream.
count(): returns the number of elements in the stream.
collect(Collector<T, A, R> collector): collects the elements in the stream into a container, such as a List, Set, or Map.
reduce(T identity, BinaryOperator<T> accumulator): reduces the elements in the stream to a single value using a given binary operator.

For example, the following code filters even numbers from a stream of integers, maps each element to its square, and then prints the result:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
       .filter(n -> n % 2 == 0)
       .map(n -> n * n)
       .forEach(System.out::println);

This would output:

4
16

Streams in Java 8 provide a powerful and flexible way to manipulate collections of data. By combining intermediate and terminal operations, you can easily perform complex transformations on your data in a concise and efficient manner.

Java Stream Interface Methods:

The Stream interface in Java 8 provides several methods that allow you to perform various operations on the stream. Here are some of the most commonly used methods:

Intermediate Operations

filter(Predicate<T> predicate): Returns a new stream containing only the elements that match the given predicate.
map(Function<T, R> mapper): Returns a new stream containing the results of applying the given function to each element in the original stream.
flatMap(Function<T, Stream<R>> mapper): Returns a new stream by applying a function to each element of the original stream, and then flattening the resulting streams into a single stream.
distinct(): Returns a new stream containing only distinct elements.
sorted(): Returns a new stream sorted in natural order.
peek(Consumer<T> action): Returns a new stream that applies the given action to each element in the stream without modifying the elements themselves.

Terminal Operations

forEach(Consumer<T> action): Applies the given action to each element in the stream.
count(): Returns the number of elements in the stream.
collect(Collector<T, A, R> collector): Collects the elements in the stream into a container, such as a List, Set, or Map.
reduce(T identity, BinaryOperator<T> accumulator): Applies the given binary operator to the elements in the stream and returns the result.
min(Comparator<T> comparator): Returns the minimum element of the stream according to the given comparator.
max(Comparator<T> comparator): Returns the maximum element of the stream according to the given comparator.
anyMatch(Predicate<T> predicate): Returns true if any element in the stream matches the given predicate, false otherwise.
allMatch(Predicate<T> predicate): Returns true if all elements in the stream match the given predicate, false otherwise.
noneMatch(Predicate<T> predicate): Returns true if no elements in the stream match the given predicate, false otherwise.
findFirst(): Returns an Optional containing the first element in the stream, or an empty Optional if the stream is empty.
findAny(): Returns an Optional containing any element in the stream, or an empty Optional if the stream is empty.

These methods allow you to perform a wide variety of operations on streams in a functional and concise manner. By chaining these methods together, you can perform complex transformations on your data with ease.

Java Example: Filtering Collection without using Stream

Sure, here’s an example of filtering a collection without using streams in Java:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class FilterWithoutStreamExample {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = new ArrayList<>();

        // Filter even numbers
        for (Integer number : numbers) {
            if (number % 2 == 0) {
                evenNumbers.add(number);
            }
        }

        System.out.println(evenNumbers); // Output: [2, 4, 6, 8, 10]
    }
}

In this example, we have a collection of integers and we want to filter out the even numbers. We create a new ArrayList called evenNumbers to store the even numbers, and then use a for-each loop to iterate over the numbers collection. For each number, we check if it’s even by using the modulus operator, and if it is, we add it to the evenNumbers list.

Finally, we print out the evenNumbers list to verify that it only contains even numbers. While this approach works fine for small collections, it can become unwieldy and difficult to read for larger collections or more complex filtering conditions. This is where Java 8 streams can be a more concise and expressive solution.

Java Stream Example: Filtering Collection by using Stream

Certainly, here’s an example of filtering a collection using Java 8 streams:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterWithStreamExample {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filter even numbers using stream
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers); // Output: [2, 4, 6, 8, 10]
    }
}

In this example, we use the stream() method to create a stream from the numbers list. We then call the filter() method on the stream and pass in a lambda expression that checks whether each number is even. The filter() method returns a new stream containing only the even numbers.

We then call the collect() method on the stream and pass in Collectors.toList() to collect the even numbers into a new list. Finally, we print out the evenNumbers list to verify that it only contains even numbers.

Using streams allows us to write more concise and expressive code. We can chain multiple stream operations together to create more complex transformations on our data. Additionally, streams can automatically parallelize operations, which can lead to improved performance on multi-core machines.

Java Stream Iterating Example:

Sure, here’s an example of iterating through a collection using Java 8 streams:

import java.util.Arrays;
import java.util.List;

public class StreamIteratingExample {

    public static void main(String[] args) {

        List<String> fruits = Arrays.asList("apple", "banana", "orange", "kiwi");

        // Iterate through the fruits using a stream
        fruits.stream().forEach(fruit -> {
            System.out.println(fruit);
        });
    }
}

In this example, we have a list of fruits and we want to iterate through them using a stream. We call the stream() method on the fruits list to create a stream, and then call the forEach() method on the stream. We pass in a lambda expression that takes a String parameter (which represents each fruit in the stream) and prints it to the console.

The forEach() method will iterate through each element in the stream and apply the lambda expression to it. In this case, it will print each fruit to the console.

Streams provide a concise and expressive way to iterate through collections, especially when combined with other stream operations like filtering, mapping, and reducing. Additionally, streams can be parallelized automatically, which can improve performance on multi-core machines.

Java Stream Example: Filtering and Iterating Collection

Certainly, here’s an example of filtering and iterating through a collection using Java 8 streams:

import java.util.Arrays;
import java.util.List;

public class StreamFilterAndIterateExample {

    public static void main(String[] args) {

        List<String> fruits = Arrays.asList("apple", "banana", "orange", "kiwi");

        // Filter and iterate through the fruits using a stream
        fruits.stream()
              .filter(fruit -> fruit.startsWith("a"))
              .forEach(System.out::println);
    }
}

In this example, we have a list of fruits and we want to filter out only the fruits that start with the letter “a”. We use the stream() method to create a stream from the fruits list, and then call the filter() method on the stream. We pass in a lambda expression that checks whether each fruit starts with the letter “a”. The filter() method returns a new stream containing only the fruits that pass the filter.

We then call the forEach() method on the filtered stream and pass in a method reference to System.out::println. This will print each fruit that passed the filter to the console.

Using streams allows us to write more concise and expressive code that combines filtering, mapping, and other operations in a single chain. We can easily iterate through the filtered elements using the forEach() method, and the stream will handle the iteration automatically, including parallelizing the operation if possible.

Java Stream Example : reduce() Method in Collection

Sure, here’s an example of using the reduce() method in a Java 8 stream to combine the elements of a collection into a single value:

import java.util.Arrays;
import java.util.List;

public class StreamReduceExample {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Sum all the numbers using reduce
        int sum = numbers.stream()
                         .reduce(0, (a, b) -> a + b);

        System.out.println(sum); // Output: 15
    }
}

In this example, we have a list of integers and we want to calculate their sum using a stream. We call the stream() method on the numbers list to create a stream, and then call the reduce() method on the stream. We pass in an initial value of 0 and a lambda expression that takes two integer parameters a and b and returns their sum a + b.

The reduce() method applies the lambda expression to each element in the stream, accumulating the results into a single value. In this case, it sums all the integers in the stream and returns the result.

Using the reduce() method, we can easily combine the elements of a collection into a single value using a stream. We can apply any binary operation to the elements, such as multiplication, concatenation, or finding the maximum or minimum value. The initial value passed to the reduce() method determines the type of the result, which can be a different type than the elements in the stream.

Java Stream Example: Sum by using Collectors Methods

Certainly, here’s an example of using the Collectors class in a Java 8 stream to sum the elements of a collection:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamCollectorsExample {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Sum all the numbers using Collectors.summingInt
        int sum = numbers.stream()
                         .collect(Collectors.summingInt(Integer::intValue));

        System.out.println(sum); // Output: 15
    }
}

In this example, we have a list of integers and we want to calculate their sum using a stream and the Collectors class. We call the stream() method on the numbers list to create a stream, and then call the collect() method on the stream. We pass in the Collectors.summingInt() method, which returns a collector that sums the integer values in the stream.

The collect() method applies the summingInt() collector to the stream, accumulating the results into a single value. In this case, it sums all the integers in the stream and returns the result.

Using the Collectors class, we can easily perform various operations on the elements of a collection, such as grouping them by a certain criteria, finding their maximum or minimum values, or creating a new collection with a different type. The Collectors class provides many predefined collectors that can be used directly or combined to create custom collectors.

Java Stream Example: Find Max and Min Product Price

Sure, here’s an example of using Java 8 streams to find the maximum and minimum prices of products in a collection:

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class StreamMaxMinExample {

    public static void main(String[] args) {

        // Create a list of products
        List<Product> products = Arrays.asList(
                new Product("Apple", new BigDecimal("1.50")),
                new Product("Banana", new BigDecimal("0.99")),
                new Product("Orange", new BigDecimal("1.25")),
                new Product("Kiwi", new BigDecimal("2.25"))
        );

        // Find the maximum and minimum product prices using streams
        Product maxPriceProduct = products.stream()
                .max(Comparator.comparing(Product::getPrice))
                .orElseThrow(NoSuchElementException::new);

        Product minPriceProduct = products.stream()
                .min(Comparator.comparing(Product::getPrice))
                .orElseThrow(NoSuchElementException::new);

        System.out.println("Max price product: " + maxPriceProduct);
        System.out.println("Min price product: " + minPriceProduct);
    }

    private static class Product {

        private final String name;
        private final BigDecimal price;

        public Product(String name, BigDecimal price) {
            this.name = name;
            this.price = price;
        }

        public String getName() {
            return name;
        }

        public BigDecimal getPrice() {
            return price;
        }

        @Override
        public String toString() {
            return name + " ($" + price + ")";
        }
    }
}

In this example, we have a list of products, each of which has a name and a price. We want to find the product with the maximum price and the product with the minimum price using streams.

We call the stream() method on the products list to create a stream, and then call the max() and min() methods on the stream. We pass in a comparator that compares the prices of the products using the Comparator.comparing() method.

The max() and min() methods return an Optional that contains the product with the maximum or minimum price, respectively. We call the orElseThrow() method on each Optional to throw a NoSuchElementException if the Optional is empty.

We then print out the maximum and minimum price products using their toString() method.

Using streams and comparators, we can easily find the maximum and minimum elements of a collection based on any criteria, such as price, quantity, or popularity.

Java Stream Example: count() Method in Collection

Sure, here’s an example of using the count() method in Java 8 streams to count the number of elements in a collection:

import java.util.Arrays;
import java.util.List;

public class StreamCountExample {

    public static void main(String[] args) {

        // Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Count the number of elements in the list using a stream
        long count = numbers.stream().count();

        System.out.println("Number of elements in the list: " + count);
    }
}

In this example, we have a list of integers and we want to count the number of elements in the list using a stream. We call the stream() method on the numbers list to create a stream, and then call the count() method on the stream. The count() method returns the number of elements in the stream as a long.

We store the result of the count() method in a variable called count and print out the number of elements in the list.

Using the count() method, we can easily count the number of elements in a collection using a stream. We can also use other stream methods, such as filter(), map(), and reduce(), to perform various operations on the elements of the collection before counting them.

Java Stream Example : Convert List into Set

Sure, here’s an example of using Java 8 streams to convert a List into a Set:

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class StreamListToSetExample {

    public static void main(String[] args) {

        // Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 3, 4, 5, 5);

        // Convert the list to a set using a stream
        Set<Integer> setOfNumbers = numbers.stream().collect(Collectors.toSet());

        System.out.println("Original list: " + numbers);
        System.out.println("Set of numbers: " + setOfNumbers);
    }
}

In this example, we have a list of integers and we want to convert the list into a Set using a stream. We call the stream() method on the numbers list to create a stream, and then call the collect() method on the stream with the Collectors.toSet() method as an argument. The toSet() method returns a Collector that accumulates the elements of a stream into a new Set.

We store the result of the collect() method in a variable called setOfNumbers and print out the original list and the set of numbers.

Using the collect() method and the Collectors.toSet() method, we can easily convert a list into a set using a stream. We can also use other Collectors methods, such as toList(), toMap(), and joining(), to collect the elements of a stream into other types of collections.

Java Stream Example : Convert List into Map

Sure, here’s an example of using Java 8 streams to convert a List into a Map:

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamListToMapExample {

    public static void main(String[] args) {

        // Create a list of products
        List<Product> products = Arrays.asList(
                new Product("Apple", 1.99),
                new Product("Orange", 2.49),
                new Product("Banana", 0.99),
                new Product("Grapes", 3.99),
                new Product("Mango", 2.99)
        );

        // Convert the list to a map using a stream
        Map<String, Double> productMap = products.stream()
                .collect(Collectors.toMap(Product::getName, Product::getPrice));

        System.out.println("Original list: " + products);
        System.out.println("Product map: " + productMap);
    }

    static class Product {
        private String name;
        private double price;

        public Product(String name, double price) {
            this.name = name;
            this.price = price;
        }

        public String getName() {
            return name;
        }

        public double getPrice() {
            return price;
        }

        @Override
        public String toString() {
            return name + " " + price;
        }
    }
}

In this example, we have a list of Product objects and we want to convert the list into a Map where the keys are the product names and the values are the product prices using a stream. We call the stream() method on the products list to create a stream, and then call the collect() method on the stream with the Collectors.toMap() method as an argument. The toMap() method takes two functions as arguments: one to extract the key from each element of the stream (Product::getName), and one to extract the value from each element of the stream (Product::getPrice).

We store the result of the collect() method in a variable called productMap and print out the original list and the product map.

Using the collect() method and the Collectors.toMap() method, we can easily convert a list into a map using a stream. We can also use other functions as arguments to extract the key and value from each element of the stream.

Method Reference in stream:

Method references in Java 8 streams are a shorthand syntax for lambdas that reference an existing method by name. They are a way to simplify code by allowing you to pass a method as an argument to a higher-order function without explicitly defining a lambda that calls the method.

There are four types of method references:

Reference to a static method: ClassName::methodName
Reference to an instance method of a particular object: object::methodName
Reference to an instance method of an arbitrary object of a particular type: ClassName::methodName
Reference to a constructor: ClassName::new

Here’s an example of using method references in a stream:

There are four types of method references:

Reference to a static method: ClassName::methodName
Reference to an instance method of a particular object: object::methodName
Reference to an instance method of an arbitrary object of a particular type: ClassName::methodName
Reference to a constructor: ClassName::new

Here’s an example of using method references in a stream:

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

        // Example 1: Reference to a static method
        words.stream()
                .map(String::toUpperCase)
                .forEach(System.out::println);

        // Example 2: Reference to an instance method of a particular object
        String prefix = "The fruit is: ";
        words.stream()
                .map(prefix::concat)
                .forEach(System.out::println);

        // Example 3: Reference to an instance method of an arbitrary object of a particular type
        words.stream()
                .sorted(String::compareToIgnoreCase)
                .forEach(System.out::println);

        // Example 4: Reference to a constructor
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.stream()
                .map(Integer::new)
                .forEach(System.out::println);
    }
}

In this example, we have a list of words and we use method references to perform various operations on the stream. In example 1, we use a reference to the toUpperCase method of the String class to convert each word to uppercase. In example 2, we use a reference to the concat method of the prefix object to add a prefix to each word. In example 3, we use a reference to the compareToIgnoreCase method of the String class to sort the words in a case-insensitive manner. In example 4, we use a reference to the Integer constructor to convert each integer to an object.

Method references can make your code more concise and readable by eliminating boilerplate code. They are especially useful when you need to pass a method as an argument to a higher-order function.