java 8 dos and don'ts - javabin oslo may 2015

Java 8 and .

javaBin Oslo – 12.05.2015

Fredrik Vraalsen

fredriv vraalsen@iterate.no

Java 8 – what’s new?Lambdas

Method handles

Extension methods

Streams

Optional3

Java 8 – what’s new?Lambdas (anonymous functions)

Method handles

Extension methods

Streams

Optional4

Java 7 vs 8Collections.sort(people, new Comparator<Person>() { public int compare(Person x, Person y) { return x.getName().compareTo(y.getName()); } });

sort(people, (x, y) -> x.getName().compareTo(y.getName()));

sort(people, comparing(person -> person.getName()));

sort(people, comparing(Person::getName));

people.sort(comparing(Person::getName));

Streams

Old fashioned imperative

List<RoadData> filtered = new ArrayList<>();int count = 0; for (Iterator<RoadData> i = roadData.iterator(); i.hasNext() && count < 10; ) { RoadData data = i.next(); if (nameQuery.matches(data.getName())) { filtered.add(data); count++; }}

Streams

roadData.stream() .filter(data -> nameQuery.matches(data.getName())) .limit(10) .collect(toList());

Streams – pipelines

cat roadData.txt | grep … | head > output.txt

Learn you a Stream API

Map<String, List<Article>> articlesByCategory =

Map<String, List<Article>> articlesByCategory = articleTransports.stream()

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(transport -> convertToArticle(transport))

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(transport -> convertToArticle(transport)) .collect(groupingBy(article -> article.getCategory()));

Method handles

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(transport -> convertToArticle(transport)) .collect(groupingBy(article -> article.getCategory()));

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(this::convertToArticle) .collect(groupingBy(article -> article.getCategory()));

Method handles

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(this::convertToArticle) .collect(groupingBy(Article::getCategory));

Naming, caching, counting

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(this::convertToArticle) .collect(groupingBy(Article::getCategory));

Naming, caching, counting

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(this::transportToArticle) .collect(groupingBy(Article::category));

Extract functions

Map<String, List<Article>> articlesByCategory = articleTransports.stream() .map(transportToArticle) .collect(groupingBy(Article::category));

Function<ArticleTransport, Article> transportToArticle = transport -> convertToArticle(transport);

Lambdas everywhere!!!1!links.stream() .map(link -> link.build()) .forEach(abderaElement::addLink);

Old school ifs and forslinks.stream() .map(link -> link.build()) .forEach(abderaElement::addLink);

for (LinkBuilder lb : links) { abderaElement.addLink(lb.build()); }

Parsing nested JSON "suggest": { "tag_suggest": [ { "length": 5, "offset": 0, "options": [ { "freq": 25, "score": 0.8, "text": "fakta" } ], "text": "fanta" } ] } 28

Lambdas everywhere!!!1!List<String> terms = new ArrayList<>();

suggestions.getAsJsonObject().getAsJsonArray(“tag_suggest”) .forEach(tag -> tag.getAsJsonObject().getAsJsonArray("options") .forEach(option -> terms .add(option.getAsJsonObject().getAsJsonPrimitive("text") .getAsString())));

Old school ifs and forsList<String> terms = new ArrayList<>();

for (JsonElement tag : suggestions.getAsJsonObject().getAsJsonArray("tag_suggest")) { for (JsonElement option : tag.getAsJsonObject().getAsJsonArray("options")) { terms.add(option.getAsJsonObject().getAsJsonPrimitive("text").getAsString()); } }

Old school ifs and forsList<String> terms = new ArrayList<>();

for (JsonElement tag : getAll("tag_suggest", suggestions)) { for (JsonElement option : getAll("options", tag)) { terms.add(getString("text", option)); } }

List<String> terms = getAll("tag_suggest", suggestions).stream() .flatMap(tag -> getAll("options", tag).stream()) .map(option -> getString("text", option)) .collect(Collectors.toList());

Lambdas everywhere!!!1!

Readability ≫ Style / LOC

Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live.

http://c2.com/cgi/wiki?CodeForTheMaintainer

OH NOES

NullPointerException!!?!© Fredrik Vraalsen 201

Optional<T>Wrapper object

Make explicit if a value is present or absent (empty)

Optional examplepublic Optional<Image> getImage(Article article)

Optional<Image> image = getImage(article);

Check presencepublic Optional<Image> getImage(Article article)

Optional<Image> image = getImage(article);if (image.isPresent()) { doSomething(image.get());}

Optional<Image> image = getImage(article);image.ifPresent(img -> doSomething(img));

getImage(article).ifPresent(image -> doSomething(image));

Default / fallback valuepublic Optional<Image> getImage(Article article)

Image image = getImage(article).orElse(defaultImage);

Optional in / Optional outpublic Optional<String> getCaption(Optional<Image> image)

Optional<Image> image = getImage(article);Optional<String> caption = getCaption(image);

Optional in / Optional outpublic String getCaption(Image image)

Optional<Image> image = getImage(article);Optional<String> caption = ???

Reaching into the void …public String getCaption(Image image)

Optional<Image> image = getImage(article);Optional<String> caption = image.map(img -> getCaption(img));

Reaching into the void …public String getCaption(Image image)

Optional<String> caption = getImage(article) .map(img -> getCaption(image));

Bye bye NullPointerException?Marker – this may not return/contain value

Public APIs

Not a general solution to NPEs

Optional + Streams = true?

myStream.map(v -> functionReturningOptional(v))

Stream<Optional<T>>

Stream<Optional<T>> ⇒ Stream<T> ???

Guava Optional

Iterable<T> presentInstances(Iterable<Optional<T>> optionals)

public Optional<Image> getImage(Article article)

List<Image> images = articles.stream() // Stream<Article>

List<Image> images = articles.stream() // Stream<Article> .map(article -> getImage(article)) // Stream<Optional<Image>>

List<Image> images = articles.stream() // Stream<Article> .map(article -> getImage(article)) // Stream<Optional<Image>> .filter(Optional::ifPresent) .map(Optional::get) // Stream<Image>

List<Image> images = articles.stream() // Stream<Article> .map(article -> getImage(article)) // Stream<Optional<Image>> .filter(Optional::ifPresent) .map(Optional::get) // Stream<Image> .collect(toList());

flatMap to the rescue!flatMap = map + flatten

Stream<Stream<T>> ⇒ Stream<T>

flatMap to the rescue!flatMap = map + flatten

Stream<Optional<T>> ⇒ Stream<T> ???

flatMap to the rescue!Easy to create helper functions

Stream<T> toStream(Optional<T> optValue)

http://stackoverflow.com/questions/22725537/using-java-8s-optional-with-streamflatmap

List<Image> images = articles.stream() // Stream<Article> .map(article -> getImage(article)) // Stream<Optional<Image>> .filter(Optional::ifPresent) .map(Optional::get) // Stream<Image> .collect(toList());

Optional + Streams = true

List<Image> images = articles.stream() // Stream<Article> .flatMap(article -> toStream(getImage(article))) // Stream<Image> .collect(toList());

Optional + Streams = true

List<Image> images = articles.stream() // Stream<Article> .flatMap(article -> getImage(article).stream()) // Stream<Image> .collect(toList());

Java 9

https://bugs.openjdk.java.net/browse/JDK-8050820

Take one stream and pass it around…

public Stream<Image> getImage(Article article)

List<Image> images = articles.stream() // Stream<Article> .flatMap(article -> getImage(article)) // Stream<Image> .collect(toList());

No method handle for you!

private Article elementToArticle(Map contentById, Element el)

List<Article> articles = elements.stream() .map(el -> elementToArticle(contentById, el)) .collect(toList())

http://en.wikipedia.org/wiki/Malabar_matthi_curry#/media/File:Meen_curry_2_(cropped).JPG

Yummy currying!!

Mapper mapper = new Mapper(contentById);

List<Article> articles = elements.stream() .map(el -> mapper.elementToArticle(el)) .collect(toList())

Yummy currying!!

Mapper mapper = new Mapper(contentById);

List<Article> articles = elements.stream() .map(mapper::elementToArticle) .collect(toList())

Performance

Streams – performanceList<Article> frontpageArticles = frontpage.getArticleIds().stream() .map(id -> fetchArticle(id)) .collect(toList());

This one goes to 11!List<Article> frontpageArticles = frontpage.getArticleIds().parallelStream() .map(id -> fetchArticle(id)) .collect(toList());

StarvationCommon F/J thread pool

Workarounds?

Execute within explicit F/J pool

Use CompletableFuture

CompletableFutureChaining of async futures and actions

Waiting for all or any future(s)

Explicitly complete (like Promise)

Control of executor service

http://blog.krecan.net/2014/03/18/how-to-specify-thread-pool-for-java-8-parallel-streams/http://www.nurkiewicz.com/2013/05/java-8-completablefuture-in-action.html

To parallelStream or not to …Batch?

parallelStream FTW!

Interactive? Concurrency?

CompletableFuture FTW!72

Taking the happy path!Try<RestResponse<ResolvedUri>> resolveURI(URI uri)

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri))

??? Try<RestResponse<ResolvedUri>>

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri)) .map(response -> response.getEntity())

??? Try<Optional<ResolvedUri>>

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri)) .map(response -> response.getEntity().get())

??? Try<ResolvedUri>

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri)) .map(response -> (ResolvedSectionUri) response.getEntity().get())

??? Try<ResolvedSectionUri>

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri)) .map(response -> (ResolvedSectionUri) response.getEntity().get()) .orElse(null);

public ResolvedSectionUri resolveSectionUri(String uri) { return client.resolveURI(uri)) .map(response -> (ResolvedSectionUri) response.getEntity().get()) .orElseGet(() -> { log.warn("Cannot resolve section from URI: {}", uri); return null; });}

https://github.com/lambdista/try

More cool stuff in Java 8String join

Collection removeIf (≈ filter)

Map getOrDefault, putIfAbsent, replace, forEach, etc.

java.util.Optional

java.util.stream.Collectors

count, sum, average, min, max, groupingBy, etc.

java.nio.file.Files lines79

Functional programmingSimpler code

More robust

Better performance

Higher levelDeclarative

Less verbose

Less bugs?

List<RoadData> filtered = new ArrayList<>();int count = 0; for (Iterator<RoadData> i = roadData.iterator(); i.hasNext() && count < 10; ) { RoadData data = i.next(); if (nameQuery.matches(data.getName())) { filtered.add(data); count++; } }

Pure functions

Data In Data Out

Transformation

No external interactions

Functional core

————- —— ——— —- — —- —-—————————— —- — —- ——————— — — — ——-——- —- — —————- ——— ——————- —— ———— - —-———- — —- — -

Pure functionsI/O I/O

Building blocks

What’s missing?Immutability

Value types

Data structures (lists, maps, etc.)

Concurrency

What’s the big deal?Functional programming is all about values!

And transformations (functions) computing new values

Parallellism vs. Concurrency

Robustness

Testability

Some help to be foundImmutable collections

Google Guava, FunctionalJava, clj-ds

Concurrency mechanisms

Akka (Actors, STM)

github.com/krukow/clj-dsPersistentVector<Person> people = Persistents.vector( new Person("Fredrik", 39), new Person("Hedda", 3));

PersistentVector<Person> morePeople = people.plus(new Person("Johannes", 5));

github.com/krukow/clj-dsPersistentVector<Person> people = Persistents.vector( new Person("Fredrik", 39), new Person("Hedda", 3));

PersistentVector<Person> morePeople = people.plus(new Person("Johannes", 5));

morePeople.stream() .forEach(p -> System.out.println(p.getName()));

Why use X instead?Java 8 ready for enterprise dev?

JBoss AS, WebSphere – Nope

WildFly, GlassFish, WebLogic, Jetty, Tomcat – OK?

Important things are still missing from Java 8

Clojure and Scala available on JDK 6+!

Questions?

fredriv

vraalsen@iterate.no

java 8 dos and don'ts - javabin oslo may 2015

stream api

map articlesbycategory

return x

vs sortpeople

public int compareperson

new comparator

person y

whats new

Software

powerpoint do's & don'ts

the don'ts of powerpoint

social media marketing don'ts

website do's don'ts

social media do's & don'ts

g+ do's & don'ts

do’s & don'ts of powerpoint

linkedin dos & don'ts

dos, don'ts & dialogue

effective powerpoint presentations. do’s do’s & don'ts...

twitter do's and don'ts

deity do's and don'ts

do's and don'ts 2014

dos and don'ts

18 basic blogging don'ts

javascript neednt hurt - javabin talk

kidznotes brand do's & don'ts

do and don'ts - secep

do's and don'ts

juma khutba-dos & don'ts