Upload
ganesh-samarthyam
View
1.067
Download
3
Embed Size (px)
Citation preview
Productive Programming
in Java 8
Covering Lambdas and Streams
ocpjava.wordpress.com
Ganesh Samarthyam ([email protected])
❖ 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 [email protected]
website www.designsmells.com
twitter @GSamarthyam
linkedin bit.ly/sgganesh
slideshare slideshare.net/sgganesh