The Ultimate 30-Minute Coding Workout - Streams & Lambda Expressions by Examples

package java.lang;

@FunctionalInterface

public interface Runnable {

public abstract void run();

}

So, it is possible to assign and execute a Lambda Expression:

Runnable myRunnable = () -> System.out.println("Hello World!");

myRunnable.run();

Expected output:

Hello World!

private static final List<Point> points = createPoints();

private static List<Point> createPoints() {

List<Point> result = new ArrayList<>();

result.add(new Point(-4, -8));

result.add(new Point(-2, 9));

result.add(new Point(-1, -8));

result.add(new Point(0, -7));

result.add(new Point(1, 1));

result.add(new Point(2, 3));

result.add(new Point(2, 3));

result.add(new Point(2, -2));

result.add(new Point(4, -1));

return result;

}

The class java.awt.Point is just a very simple class that holds two number and this is convenient for calculations. With some minor changes all the examples can work with different classes.

Standard in Java to Print all Elements of a List

Before we start with lambdas we have a look at the standard way in Java to print all elements of the list:

for (Point point : points) {

System.out.print(point);

}

Expected output:

java.awt.Point[x=-4,y=-8]java.awt.Point[x=-2,y=9]java.awt.Point[x=-1,y=-8]

java.awt.Point[x=0,y=-7]java.awt.Point[x=1,y=1]java.awt.Point[x=2,y=3]

java.awt.Point[x=2,y=3]java.awt.Point[x=2,y=-2]java.awt.Point[x=4,y=-1]

Here the Iterator of the list is used to get each Point and do then the print operation. We use an External Iterator (aka Active Iterator) - this gives full control over the order of execution, exception handling, etc. This is in principal good but the code is serial and can just be executed in a parallel way with serious effort.

ForEach Lambda Expression or Method Reference to Print all Elements of a List

The Iterable.forEach() method can take a lambda expression:

points.forEach(p -> System.out.print(p));

or an instance method reference (System.out is an instance of PrintStream):

points.forEach(System.out::print);

Expected output:

java.awt.Point[x=-4,y=-8]java.awt.Point[x=-2,y=9]java.awt.Point[x=-1,y=-8]

java.awt.Point[x=0,y=-7]java.awt.Point[x=1,y=1]java.awt.Point[x=2,y=3]

java.awt.Point[x=2,y=3]java.awt.Point[x=2,y=-2]java.awt.Point[x=4,y=-1]

Here the forEach() of the stream is used to call the print operation. We call this an Internal Iterator (aka Passive Iterator) - which delegates the control to the Java run time. This code can be executed in a serial and parallel way. The disadvantage is that the order is not deterministic in the case it is executed in a parallel way.

ForEach to Print all Elements of a List with Special Formatting

With the following helper method the output can be printed in a more convenient format:

private static void printFormated(Point p) {

System.out.print("[" + p.x + ", " + p.y + "] ");

}

Then we can use a simple lambda expression:

points.forEach(p -> printFormated(p));

or we can use a static method reference:

points.forEach(LambdaBasics::printFormated);

Expected output:

[-4, -8] [-2, 9] [-1, -8] [0, -7] [1, 1] [2, 3] [2, 3] [2, -2] [4, -1]

int result = points.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.reduce(0, (x1, x2) -> x1 + x2); // initial value is needed

System.out.print("\nsum=" + result);

Expected output:

-4 -2 -1 0 1 2 2 2 4

sum=4

The intermediate operation peek() exists mainly to support debugging, where you want to see the elements as they flow past a certain point in a pipeline (see Interface Stream<T>).

Calculate Sum of all X-Coordinates with mapToInt () and reduce() and ifPresent()

The initial value in the reduce() method can be empty, but in this case you should be sure that the stream has elements. If the stream could be empty the terminal operator ifPresent() should be.

points.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.reduce((x1, x2) -> x1 + x2) // no initial value is used

.ifPresent(s -> System.out.print("\nsum=" + s)); // in the case there is no empty list

Expected output:

-4 -2 -1 0 1 2 2 2 4

sum=4

You may notice that the terminal operation reduce is not the last called method. In this case the return value of reduce() is the container object OptionalInt. This class has the method ifPresent() which is called. Other useful methods of this container are isPresent(), orElse() and getAsInt().

Calculate Sum of all X-Coordinates with sum()

An other way to calculate the sum are the statistics functions of stream class.

int result = points.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.sum(); // standard IntStream method (like min, max, average, count)

System.out.print("\nsum=" + result);

Expected output:

-4 -2 -1 0 1 2 2 2 4

sum=4

Calculate Sum of all X-Coordinates with reduce() on Empty List

Notice that pointsEmpty is an empty list For empty lists the behavior may be different. As long the reduce() method has an initial value, the result is correct:

int result = pointsEmpty.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.reduce(0, (x1, x2) -> x1 + x2); // initial value is needed

System.out.print("\nsum=" + result);

Expected output:

sum=0

Calculate Sum of all X-Coordinates with reduce() and ifPresent() on Empty List

Notice that ifPresent() method doesn't execute the lambda for an empty list.

pointsEmpty.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.reduce((x1, x2) -> x1 + x2) // no initial value is used

.ifPresent(s -> System.out.print("\nsum=" + s)); // in the case there is no empty list

Expected output (is empty):

Calculate Sum of all X-Coordinates with sum() on Empty List

The sum() method works properly also with an empty list.

int result = pointsEmpty.stream()

.mapToInt(p -> p.x) // map the x value of the point to IntStream

.peek(x -> System.out.print(x + " ")) // trace the values

.sum(); // standard IntStream method (like min, max, average, count)

System.out.print("\nsum=" + result);

Expected output:

sum=0

Use of filter() and distinct()

Filter all Points which are Positive in X with Lambda Expression

points.forEach(p -> {

if (p.x > 0) {

printFormated(p);

}

});

Expected output:

[1, 1] [2, 3] [2, 3] [2, -2] [4, -1]

Filter all Points which are Positive in X with filter()

points.stream().filter(p -> p.x > 0).forEach(LambdaBasics::printFormated);

Expected output:

[1, 1] [2, 3] [2, 3] [2, -2] [4, -1]

Filter Distinct Points which are Positive in X with filter()

points.stream().filter(p -> p.x > 0).distinct().forEach(LambdaBasics::printFormated);

Expected output:

List<Point> points = createPoints();

try {

points.stream() // modify during iteration

.filter(p -> p.x == 2) // but just some points

.map(p -> new Point(100 * p.x, 10 * p.y)) // create a new point

.forEach(points::add); // add new the point

points.forEach(LambdaBasics::printFormated); // print results

} catch (ConcurrentModificationException e) {

System.out.println(e.toString());

}

Expected output:

java.util.ConcurrentModificationException

Add Point to New List in the Case the X-Value is Equal Two

This implementation is correct!

Stream<Point> pointsResults = Stream.concat( // concatenate two streams

points.stream(), // original stream

points.stream() // add points to new stream

.filter(p -> p.x == 2) // but just some points

.map(p -> new Point(100 * p.x, 10 * p.y))

);

pointsResults.forEach(LambdaBasics::printFormated); // print results

Expected output:

List<Point> result = points.stream()

.filter(p -> p.getX() > 0)

.collect(Collectors.toCollection(ArrayList::new));

result.forEach(LambdaBasics::printFormated);

Expected output:

[1, 1] [2, 3] [2, 3] [2, -2] [4, -1]

The interesting thing here it the Collectors.toCollection(ArrayList::new) which creates a new ArrayList and fills it.

Use Collectors to Create Comma Separated String

String resultString = points.stream()

.mapToInt(p -> p.x) // extract x value

.mapToObj(Integer::toString) // create String with integer value

.collect(Collectors.joining(", ")); // create string

System.out.println(resultString);

Expected output:

-4, -2, -1, 0, 1, 2, 2, 2, 4

package com.sw_engineering_candies.examples;

@FunctionalInterface

public interface PerformanceTestLambda {

void execute();

}

The helper class for the test cases:

package com.sw_engineering_candies.examples;

public class PerformanceTestCase {

private PerformanceTestLambda lambda;

private String comment;

public PerformanceTestCase(

PerformanceTestLambda lambda,

String comment) {

this.lambda = lambda;

this.comment = comment;

}

public PerformanceTestLambda getLambda() {

return lambda;

}

public String getComment() {

return comment;

}

}

An the test runner:

package com.sw_engineering_candies.examples;

import java.util.ArrayList;

import java.util.List;

public class PerformanceTestRunner {

private static final int EXECUTION_CYCLES = 100;

private static final int WARM_UP_CYCLES = 200;

private static final List<PerformanceTestCase> tests = new ArrayList<>();

public static void add(String description, PerformanceTestLambda block) {

tests.add(new PerformanceTestCase(block, description));

}

public static void executeAll() {

System.out.println();

tests.forEach(PerformanceTestRunner::initialize);

System.out.println();

tests.forEach(PerformanceTestRunner::execute);

}

private static void execute(PerformanceTestCase testCase) {

long start = System.currentTimeMillis();

for (int count = 0; count < EXECUTION_CYCLES; count++) {

testCase.getLambda().execute();

}

double duration = ((double) (System.currentTimeMillis() - start)

/ EXECUTION_CYCLES);

System.out.println("test case '" + testCase.getComment()

+ "' elapsed time per execution "

+ duration + " ms");

}

private static void initialize(PerformanceTestCase testcase) {

System.out.print("test case '" + testcase.getComment() + "' warm-up ");

for (int count = 0; count < WARM_UP_CYCLES; count++) {

testcase.getLambda().execute();

if (count % (WARM_UP_CYCLES / Math.min(20, WARM_UP_CYCLES)) == 0) {

System.out.print(".");

}

}

System.out.println(" ready");

}

}

Then the following performance tests can be executed:

package com.sw_engineering_candies.examples;

import java.util.ArrayList;

import java.util.List;

import com.google.common.base.Preconditions;

public class LambdaPerformance {

private static final int NUMBER_OF_DATA = 100000;

private static List<Double> values = new ArrayList<>(NUMBER_OF_DATA);

static {

for (int i = 0; i < NUMBER_OF_DATA; i++) {

values.add(Math.random());

}

}

public static void main(String[] args) {

PerformanceTestRunner.add("standard for-loop", () -> {

double result = Double.MIN_VALUE;

double y = Double.MIN_VALUE;

for (double x : values) {

y = Math.cos(x);

if (y > result) {

result = y;

}

}

});

PerformanceTestRunner.add("sequential", () -> {

double result = values.stream()

.mapToDouble(Math::cos)

.reduce(Double.MIN_VALUE, (i, j) -> Math.max(i, j));

});

PerformanceTestRunner.add("parallel", () -> {

double result = values.parallelStream()

.mapToDouble(Math::cos)

.reduce(Double.MIN_VALUE, (i, j) -> Math.max(i, j));

});

PerformanceTestRunner.executeAll();

}

}

Expected output:

test case 'standard for-loop' warm-up .................... ready

test case 'sequential' warm-up .................... ready

test case 'parallel' warm-up .................... ready

test case 'standard for-loop' elapsed time per execution 5.68 ms

test case 'sequential' elapsed time per execution 6.1 ms

test case 'parallel' elapsed time per execution 1.79 ms