Productive Programming

in Java 8

Covering Lambdas and Streams

ocpjava.wordpress.com

Ganesh Samarthyam (ganesh.samarthyam@gmail.com)

❖ Programming examples are from our book: ❖ Oracle Certified

Professional Java SE 8 Programmer Exam 1Z0-809: A Comprehensive OCPJP 8 Certification Guide, S.G. Ganesh, Hari Kiran Kumar, Tushar Sharma, Apress, 2016.

❖ Website: ocpjava.wordpress.com

Java

876…

I am evolving…

Java 8: Latest (red-hot)

Recent addition: lambdas

8

Greek characters are scary!

He he, but lambdas are fun, not scary

Java meets functional programming (with lambdas)

How different is lambdas?

if

while

for

switch

Introducing our star feature - lambda

functions

List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");Consumer<String> printString = string -> System.out.println(string); strings.forEach(printString);

Lambda functions!

But what are lambdas?

Lambdas is just a fancy name for functions

without a name!

What are lambdas?

❖ (Java 8) One way to think about lambdas is “anonymous function” or “unnamed function” - they are functions without a name and are not associated with any class

❖ Functions don’t change external state

Arrays.asList("eeny", "meeny", "miny", “mo”) .forEach(string -> System.out.println(string));

Internal Iteration

List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");for(String string : strings) {

System.out.println(string);}

External Iteration

Lambda expression

You can use lambdas for some amazing stuff

sediment pre-carbon ultra-filter post-

carbonFiltered water

E.g., you can compose lambda functions as in pipes-and-filters

$ cat limerick.txt There was a young lady of Niger Who smiled as she rode on a tiger. They returned from the ride With the lady inside And a smile on the face of the tiger.

$ cat limerick.txt | tr -cs "[:alpha:]" "\n" | awk '{print length(), $0}' | sort | uniq1 a 2 as 2 of 2 on 3 And 3 Who 3 she 3 the 3 was 4 They 4 With 4 face 4 from 4 lady 4 ride 4 rode 5 Niger 5 There 5 smile 5 tiger 5 young 6 inside 6 smiled 8 returned

List<String> lines = Files.readAllLines(Paths.get("./limerick.txt"), Charset.defaultCharset());

Map<Integer, List<String>> wordGroups = lines.stream() .map(line -> line.replaceAll("\\W", "\n").split("\n")) .flatMap(Arrays::stream) .sorted() .distinct() .collect(Collectors.groupingBy(String::length));

wordGroups.forEach( (count, words) -> { words.forEach(word -> System.out.printf("%d %s %n", count, word)); });

1 a 2 as 2 of 2 on 3 And 3 Who 3 she 3 the 3 was 4 They 4 With 4 face 4 from 4 lady 4 ride 4 rode 5 Niger 5 There 5 smile 5 tiger 5 young 6 inside 6 smiled 8 returned

Lambdas & streams help in productive programming!

public static void main(String []file) throws Exception { // process each file passed as argument

// try opening the file with FileReader try (FileReader inputFile = new FileReader(file[0])) { int ch = 0; while( (ch = inputFile.read()) != -1) { // ch is of type int - convert it back to char System.out.print( (char)ch ); } } // try-with-resources will automatically release FileReader object }

public static void main(String []file) throws Exception { Files.lines(Paths.get(file[0])).forEach(System.out::println); }

Existing APIs are enriched with lambdas and streams support

So, lets get our hands dirty and start coding

interface LambdaFunction { void call(); }

class FirstLambda { public static void main(String []args) { LambdaFunction lambdaFunction = () -> System.out.println("Hello world"); lambdaFunction.call(); } }

Functional interface - provides signature for lambda functions

Lambda function/expression

Call to the lambda

Prints “Hello world” on the console when executed

@FunctionalInterface interface LambdaFunction { void call(); }

Functional interface

Abstract method providing the signature of the lambda function

Annotation to explicitly state that it is a functional interface

Old functional interfaces

// in java.lang package interface Runnable { void run(); }

// in java.util package interface Comparator<T> { boolean compare(T x, T y); }

// java.awt.event package: interface ActionListener { void actionPerformed(ActionEvent e) }

// java.io package interface FileFilter { boolean accept(File pathName); }

Default methods in interfaces

public interface Iterator<E> { boolean hasNext();

E next();

default void remove() { throw new UnsupportedOperationException("remove");

}

default void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action);

while (hasNext()) action.accept(next());

} }

Diamond inheritance problem

Diamond inheritance problem?

interface Interface1 { default public void foo() { System.out.println("Interface1’s foo"); } }

interface Interface2 { default public void foo() { System.out.println("Interface2’s foo"); } }

public class Diamond implements Interface1, Interface2 { public static void main(String []args) { new Diamond().foo(); } }

Error:(9, 8) java: class Diamond inherits unrelated defaults for foo() from types Interface1 and Interface2

Diamond inheritance problem?

interface Interface1 { default public void foo() { System.out.println("Interface1’s foo"); } }

interface Interface2 { default public void foo() { System.out.println("Interface2’s foo"); } }

public class Diamond implements Interface1, Interface2 { public void foo() { Interface1.super.foo(); }

public static void main(String []args) { new Diamond().foo(); } }

Add this definition to resolve the

ambiguity

Effectively final variables

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

class PigLatin { public static void main(String []args) { String suffix = "ay"; List<String> strings = Arrays.asList("one", "two", "three", "four"); strings.forEach(string -> System.out.println(string + suffix)); } } Accessing “local variable” suffix

here; hence it is considered “effectively final”

Effectively final variablesimport java.util.Arrays; import java.util.List;

class PigLatin { public static void main(String []args) { String suffix = "ay"; List<String> strings = Arrays.asList("one", "two", "three", “four");

suffix = "e"; // assign to suffix variable strings.forEach(string -> System.out.println(string + suffix)); } }

PigLatinAssign.java:9: error: local variables referenced from a lambda expression must be final or effectively final strings.forEach(string -> System.out.println(string + suffix)); ^ 1 error

arg -> System.out.println(arg)

System.out::println

Method references - “syntactic sugar” for lambda functions

They “route” function parameters

Using built-in functional interfaces

List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo"); Consumer<String> printString = string -> System.out.println(string); strings.forEach(printString);

List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo"); strings.forEach(string -> System.out.println(string));

Using built-in functional interfaces

Built-in functional interfaces are a part of the java.util.function

package (in Java 8)

Using built-in functional interfacesPredicate<T> Checks a condition and returns a

boolean value as resultIn filter() method in java.util.stream.Stream which is used to remove elements in the stream that don’t match the given Consumer<T> Operation that takes an argument

but returns nothingIn forEach() method in collections and in java.util.stream.Stream; this method is used for traversing all the elements in Function<T,

R>Functions that take an argument and return a result

In map() method in java.util.stream.Stream to transform or operate on the passed value and return a result. Supplier<T> Operation that returns a value to

the caller (the returned value could be same or different values)

In generate() method in java.util.stream.Stream to create a infinite stream of elements.

Predicate interface

Stream.of("hello", "world") .filter(str -> str.startsWith("h")) .forEach(System.out::println);

The filter() method takes a Predicate as an argument (predicates are

functions that check a condition and return a boolean value)

Predicate interface

Predicate interface

A Predicate<T> “affirms” something as true or false: it takes an argument of type T, and returns a

boolean value. You can call test() method on a Predicate object.

@FunctionalInterface public interface Predicate<T> {

boolean test(T t); // other methods elided

}

Predicate interface: example

import java.util.function.Predicate;

public class PredicateTest { public static void main(String []args) {

Predicate<String> nullCheck = arg -> arg != null; Predicate<String> emptyCheck = arg -> arg.length() > 0; Predicate<String> nullAndEmptyCheck = nullCheck.and(emptyCheck); String helloStr = "hello"; System.out.println(nullAndEmptyCheck.test(helloStr)); String nullStr = null; System.out.println(nullAndEmptyCheck.test(nullStr));

} }

Prints: truefalse

Predicate interface: example

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

public class RemoveIfMethod { public static void main(String []args) {

List<String> greeting = new ArrayList<>(); greeting.add("hello"); greeting.add("world"); greeting.removeIf(str -> !str.startsWith("h")); greeting.forEach(System.out::println);

} }

Prints: hello

Consumer interface

Stream.of("hello", "world") .forEach(System.out::println);

// void forEach(Consumer<? super T> action);

Prints: helloworld

Consumer interface

Consumer interface

A Consumer<T> “consumes” something: it takes an argument (of generic type T) and returns

nothing (void). You can call accept() method on a Consumer object.

@FunctionalInterface public interface Consumer<T> {

void accept(T t); // the default andThen method elided

}

Consumer interface: Example

Consumer<String> printUpperCase = str -> System.out.println(str.toUpperCase());

printUpperCase.accept("hello");

Prints: HELLO

Consumer interface: Example

import java.util.stream.Stream; import java.util.function.Consumer;

class ConsumerUse { public static void main(String []args) {

Stream<String> strings = Stream.of("hello", "world"); Consumer<String> printString = System.out::println; strings.forEach(printString);

} }

Prints: helloworld

Function interface

import java.util.Arrays;

public class FunctionUse { public static void main(String []args) {

Arrays.stream("4, -9, 16".split(", ")) .map(Integer::parseInt) .map(i -> (i < 0) ? -i : i) .forEach(System.out::println);

} }

Prints: 4916

Function interface

Function interface

A Function<T, R> “operates” on something and returns something: it takes one argument (of

generic type T) and returns an object (of generic type R). You can call apply() method on a Function

object.

@FunctionalInterface public interface Function<T, R> {

R apply(T t); // other methods elided

}

Function interface: example

Function<String, Integer> strLength = str -> str.length(); System.out.println(strLength.apply("supercalifragilisticexpialidocious"));

Prints: 34

Function interface: example

import java.util.Arrays; import java.util.function.Function;

public class CombineFunctions { public static void main(String []args) {

Function<String, Integer> parseInt = Integer:: parseInt ; Function<Integer, Integer> absInt = Math:: abs ; Function<String, Integer> parseAndAbsInt = parseInt.andThen(absInt); Arrays.stream("4, -9, 16".split(", "))

.map(parseAndAbsInt)

.forEach(System. out ::println); }

}

Prints: 4916

Supplier interface

import java.util.stream.Stream; import java.util.Random;

class GenerateBooleans { public static void main(String []args) {

Random random = new Random(); Stream.generate(random::nextBoolean)

.limit(2)

.forEach(System.out::println); }

}

Prints two boolean values “true” and “false”

in random order

Supplier interface

Supplier interface

A Supplier<T> “supplies” takes nothing but returns something: it has no arguments and

returns an object (of generic type T). You can call get() method on a Supplier object

@FunctionalInterface public interface Supplier<T> {

T get(); // no other methods in this interface

}

Supplier interface: example

Supplier<String> currentDateTime = () -> LocalDateTime.now().toString(); System.out.println(currentDateTime.get());

Prints current time: 2015-10-16T12:40:55.164

Summary of built-in interfaces in java.util.function interface

❖ There are only four core functional interfaces in this package: Predicate, Consumer, Function, and Supplier.

❖ The rest of the interfaces are primitive versions, binary versions, and derived interfaces such as UnaryOperator interface.

❖ These interfaces differ mainly on the signature of the abstract methods they declare.

❖ You need to choose the suitable functional interface based on the context and your need.

Java 8 streams (and parallel streams): Excellent example of applying functional

programming in practice

But what are streams?

Arrays.stream(Object.class.getMethods()) .map(method -> method.getName()) .distinct() .forEach(System.out::println);

wait equals toString hashCode getClass notify notifyAll

Method[] objectMethods = Object.class.getMethods(); Stream<Method> objectMethodStream = Arrays.stream(objectMethods); Stream<String> objectMethodNames

= objectMethodStream.map(method -> method.getName()); Stream<String> uniqueObjectMethodNames = objectMethodNames.distinct(); uniqueObjectMethodNames.forEach(System.out::println);

Arrays.stream(Object.class.getMethods()) .map(method -> method.getName()) .distinct() .forEach(System.out::println);

Breaking up into separate (looong) statements for our

understanding

stream pipelineStreamsource

Intermediateopera1ons

Terminalopera1on

stream

stream

Examples:IntStream.range(),Arrays.stream()

Examples:map(),filter(),dis1nct(),sorted()

Examples:sum(),collect(),forEach(),reduce()

DoubleStream.of(1.0,4.0,9.0) map(Math::sqrt) .peek(System.out::

println)

StreamSource(withelements1.0,4.0,and9.0)

IntermediateOpera=on1(mapsto

elementvalues1.0,2.0,and3.0)

IntermediateOpera=on2

(prints1.0,2.0,and3.0)

.sum();

TerminalOpera=on(returnsthesum6.0)

DoubleStream.of(1.0, 4.0, 9.0) .map(Math::sqrt) .peek(System.out::println) .sum();

IntStream.range(1, 6)

You can use range or iterate factory methods in the

IntStream interface

IntStream.iterate(1, i -> i + 1).limit(5)

1 2 3 4 5

1 4 9 16 25

map(i->i*i)

IntStream.range(1, 5).map(i -> i * i).forEach(System.out::println);

Using streams instead of imperative for i = 1 to 5, print i * i

Stream.of (1, 2, 3, 4, 5) .map(i -> i * i) .peek(i -> System.out.printf("%d ", i)) .count();

prints: 1 4 9 16 25

stream can be infinite

IntStream.iterate(0, i -> i + 2).forEach(System.out::println);

This code creates infinite stream of even numbers!

IntStream .iterate(0, i -> i + 2) .limit(5) .forEach(System.out::println);

Using the “limit” function to limit the stream to 5 integers

IntStream chars = "bookkeep".chars(); System.out.println(chars.count()); chars.distinct().sorted().forEach(ch -> System.out.printf("%c ", ch));

Cannot “reuse” a stream; this code throws IllegalStateException

Streams are lazy!

Files.lines(Paths.get("FileRead.java")).forEach(System.out::println);

This code prints the contents of the file “FileRead.java” in the

current directory

Pattern.compile(" ").splitAsStream("java 8 streams").forEach(System.out::println);

This code splits the input string “java 8 streams” based on whitespace and hence

prints the strings “java”, “8”, and “streams” on the console

new Random().ints().limit(5).forEach(System.out::println);

Generates 5 random integers and prints them on the console

"hello".chars().sorted().forEach(ch -> System.out.printf("%c ", ch));

Extracts characters in the string “hello”, sorts the chars and prints the chars

Parallel Streams

race conditions

deadlocks

I really really hate concurrency problems

Parallel code

Serial code

long numOfPrimes = LongStream.rangeClosed(2, 100_000) .filter(PrimeNumbers::isPrime) .count();

System.out.println(numOfPrimes);

Prints 9592

2.510 seconds

Parallel code

Serial code

Let’s flip the switch by calling parallel() function

long numOfPrimes = LongStream.rangeClosed(2, 100_000) .parallel() .filter(PrimeNumbers::isPrime) .count();

System.out.println(numOfPrimes);

Prints 9592

1.235 seconds

Wow! That’s an awesome flip switch!

Internally, parallel streams make use of fork-join framework

import java.util.Arrays;

class StringConcatenator { public static String result = ""; public static void concatStr(String str) { result = result + " " + str; } }

class StringSplitAndConcatenate { public static void main(String []args) { String words[] = "the quick brown fox jumps over the lazy dog".split(" "); Arrays.stream(words).forEach(StringConcatenator::concatStr); System.out.println(StringConcatenator.result); } }

Gives wrong results with with parallel() call

Adapt, learn functional programming!

SOLID Principles and Design Patterns

Bootcamp - 25 JUN 2016 - Bangalore

Register here: https://www.townscript.com/e/designpattern

Fee Rs. 3500 Discount (Rs. 500)

code: “First10”

Image credits• http://www.wetplanetwhitewater.com/images/uploads/adam_mills_elliott82.jpg • http://s.ecrater.com/stores/321182/53e46c705f68d_321182b.jpg • http://img.viralpatel.net/2014/01/java-lambda-expression.png • https://i.ytimg.com/vi/3C0R_fEXcYA/maxresdefault.jpg • http://farm1.static.flickr.com/74/170765090_53762a686c.jpg • http://www.monazu.com/wp-content/uploads/2012/06/ask-the-right-questions.jpg • https://s-media-cache-ak0.pinimg.com/736x/43/42/8a/43428ac2c352166374d851e895ed5db1.jpg • http://cdn.attackofthecute.com/August-17-2011-12-36-23-peekaboo-

kitty-46f32anul-131384-530-410.jpeg • https://ludchurchmyblog.files.wordpress.com/2010/02/myths-legend-pictures-083.jpg • http://www.youramazingplaces.com/wp-content/uploads/2013/06/Mauvoisin-Dam-

Switzerland-620x413.jpg • http://www.welikeviral.com/files/2014/08/Image-914.jpg • http://geekandpoke.typepad.com/.a/6a00d8341d3df553ef013485f6be4d970c-800wi • https://qph.fs.quoracdn.net/main-qimg-56547c0506050206b50b80a268bf2a84 • https://i.ytimg.com/vi/kCVsKsgVhBA/maxresdefault.jpg • http://i.livescience.com/images/i/000/022/395/original/man-dreams-bed.jpg • https://static-secure.guim.co.uk/sys-images/Guardian/Pix/pictures/2012/11/26/1353952826063/Alarm-

clock-010.jpg

email sgganesh@gmail.com

website www.designsmells.com

twitter @GSamarthyam

linkedin bit.ly/sgganesh

slideshare slideshare.net/sgganesh