Streams

Introduced in Java 8, Stream API is used to process collections.

Some of the most common functions of them are:

• forEach
• map
• filter
• allMatch
• reduce

All of this functions accept lambda function which specifies what will be done to the iterated elements.

Lambda functions don't have any names and have the following syntax:

(Parameters) -> { Body }

forEach

Iterates the elements of an List.

It accepts a function as an argument which has a single argument - the value of the iterated element.

Let's look at the following example:

import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(4, 8, 7, 6, 3); numbers.stream() .forEach((value) -> { System.out.println("Value: " + value); System.out.println("- - - - - - - -"); }); } }

Output:

Value: 4 - - - - - - - - Value: 8 - - - - - - - - Value: 7 - - - - - - - - Value: 6 - - - - - - - - Value: 3 - - - - - - - -

The code snippet prints all values of the List in a way specified in the lambda function.

map

Returns stream which elements are modified in the lambda and can be converted to List.

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(4, 8, 7, 6, 3); List<Integer> multipliedElements = numbers.stream() .map(value -> { return value * 2; }) .collect(Collectors.toList()); System.out.println(multipliedElements); } }

Output:

[8, 16, 14, 12, 6]

In this case the modification is specified according to the returned value - value * 2.

.collect(Collectors.toList()) is used to convert the map function result into list.

If the lambda function returns a single expression it can be simplified.

From this:

.map(value -> { return value * 2; })

To this:

.map(value -> value * 2) import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(4, 8, 7, 6, 3); List<Integer> multipliedElements = numbers.stream() .map(value -> value * 2) .collect(Collectors.toList()); System.out.println(multipliedElements); } }

Output:

[8, 16, 14, 12, 6]

filter

Allows filtering specific elements.

if the lambda returns true - the element will be present in the returned stream.

If the lambda returns false - it will not be present.

For example we can filter the List to return only the even numbers:

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(4, 8, 7, 6, 3); List<Integer> evenNumbers = numbers.stream() .filter(value -> value % 2 == 0) .collect(Collectors.toList()); System.out.println(evenNumbers); } }

Output:

[4, 8, 6]

allMatch

Allows checking if all elements match certain condition.

If all of the elements match the condition in the lambda (to return true), then the allMatch function returns true.

If one or more of the elements don't match the condition in the lambda (to return false), then the allMatch function returns true.

For example we can check if all of the elements in the list are even:

import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(4, 8, 7, 6, 3); List<Integer> onlyEvenNumbers = Arrays.asList(4, 8, 6); boolean result1 = numbers.stream().allMatch(value -> value % 2 == 0); boolean result2 = onlyEvenNumbers.stream().allMatch(value -> value % 2 == 0); System.out.println(result1); System.out.println(result2); } }

Output:

false true

reduce

Accumulates a single value based on a lambda function.

It has 2 arguments - the initial value and the lambda function.

The callback accepts 2 arguments - total and value in which total is the accumulated value.

An example of function summing List elements with System.out.println for explanations:

import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream() .reduce(0, (total, value) -> { System.out.println("Accumulate value: " + total); System.out.println("The value to add: " + value); System.out.println("- - - - - - - - - -"); return total + value; }); System.out.println("Sum: " + sum); } }

Output:

Accumulate value: 0 The value to add: 1 - - - - - - - - - - Accumulate value: 1 The value to add: 2 - - - - - - - - - - Accumulate value: 3 The value to add: 3 - - - - - - - - - - Accumulate value: 6 The value to add: 4 - - - - - - - - - - Accumulate value: 10 The value to add: 5 - - - - - - - - - - Sum: 15