java 8 Hands on Workshop

Java 8 Hands on Workshop
FIRST Robotics Training
July 12, 2017
Jeanne Boyarsky
Twitter @jeanneboyarsky
Blog: http://www.selikoff.net

Disclaimer: Some of this material is copyright of Jeanne
Boyarsky, Scott Selikoff and/or Wiley Publishing
Twitter: @jeanneboyarsky
This PowerPoint is part of a hands
on workshop for teaching fluency
with Java 8 stream basics.

Pre-req:
Basic Java knowledge is required. If you can
implement this method using a loop, you
are good:
public int countStringsThatAreFourChars(
List<String> list) {
}

Groovy vs Java
print(
list
.grep{ j -> j.disabled }
.collect { j-> j.name }
)
list.stream()
.filter(j -> j.disabled)
.map(j -> j.name)
.forEach(
System.out::println);

TryYourIde.java
(5 mins)
• Local IDE
or
• https://www.compilejava.net
https://github.com/boyarsky/java-8-
streams-by-puzzles
Run src/TryYourIde class
Prints Do stuff and Do more stuff

Lambda vs Boilerplate
filter(j -> ! j.disabled)
filter(new Predicate<Job>() {
public boolean test(Job j) {
return ! j.disabled;
}
})

Basic Lambdas

Full Lambda Syntax

Java 8 Lambda Syntax Rules
Must have parens
unless exactly one
parameter
If listing type, must
be consistent
If multiple
statements: requires
braces, return and
semicolon
• () -> true
• a -> a.startsWith("test")
• (String a) ->
a.startsWith("test")
• (a, b) ->
a.startsWith("test")
• (String a, String b) ->
{ return
a.startsWith("test"); }

What’s wrong?
• a, b -> a.startsWith("test")
• a -> { a.startsWith("test"); }
• a -> { return a.startsWith("test") }
• (String a, b) -> a.startsWith("test")
• -> a.startsWith("test”)

Using variables
interface Gorilla { String move(); }
class GorillaFamily {
String walk = "walk";
void everyonePlay(boolean baby) {
String approach = "amble";
//approach = "run";
play(() -> walk);
play(() -> baby ? "hitch a ride" : "run");
play(() -> approach);
}
void play(Gorilla g) {
g.move();
}
}
1) Instance var
2) Class var
3) Effectively final
method param
or local var

LambdaFillInTheBlanks.java
(10-15 mins)
Easy - Fill in the blank so prints
out the numbers less than 3:
Stream.of(1, 2, 3, 5, 8)
.filter(__________)
.forEach(System.out::println);
Easy - Fill in the blank so prints out the
animals that are 4 characters in length:
Stream.of("cat", "dot", "fish", "rabbit")
.filter((p) -> { ___________ })
Medium - Fill in the blank so
prints the number 1:
long count = Stream.of(
"IBM", "Oracle", "Pivotal")
.filter(___________________)
.count();
System.out.println(count);
Challenge - How many
ways can you write a
lambda that takes one
String parameter named
“s” and returns the result of
s.isEmpty()?

Predicate?

Find the Functional Interface(s)
interface Slower {
double getCrawlSpeed();
String toString();
default int getSlowestSpeed() { return 0; }
static int getFastestSpeed() { return 10; }
}
interface Swimmer {
double getSwimSpeed();
}
interface Faster extends Slower {
double getFasterSpeed();
}

Common Functional Interface(s)
+ existing
interfaces
like
Comparable

FunctionalInterfacesFillInTheBlanks.java
(10-15 mins)
Easy: Predicate<String> p = s -> s.isEmpty();
Easy: Function<String, Integer> f = ________________;
Medium: Consumer<Double> c = ________________;
Hard: Supplier<Integer> s = _______________;
Challenge: How many ways can you fill in this blank?
_____________ ex = x -> "".equals(x.get(0));

Parts of a Stream Pipeline

Example of a Stream Pipeline

List<String> filtered = new ArrayList<>();
for (String name : list) {
if (name.length() == 4)
filtered.add(name);
}
Collections.sort(filtered);
List<String> result = filtered.subList(0, 2);
for (String name : result)
System.out.println(name);
Comparing code
list.stream()
.filter(n -> n.length() == 4)
.sorted().limit(2)

Example of a Chain

What happens if missing?
• If no source?
• If no intermediate operations?
• If no terminal operation?

Creating a Finite Stream
Stream<String> empty = Stream.empty();
Stream<Integer> singleElement =
Stream.of(1);
Stream<Integer> fromArray =
Stream.of(1, 2, 3);
List<String> list =
Arrays.asList("a", "b", "c");
Stream<String> fromList = list.stream();

Creating an Infinite Stream
Stream<Double> randoms =
Stream.generate(Math::random);
Stream<Integer> oddNumbers =
Stream.iterate(1, n -> n + 2);

Terminal Operations

Puzzle – No Intermediate Operations
(10 mins)
Easy:
Using the puzzle 1 handouts, arrange so the code
prints
true true 3
boolean b1 = ______.___________;
boolean b2 = ________.__________;
long l = ________.________;
System.out.println(b1 + " " + b2 + " " + l);

TranslateSearch.java
(5-10 mins)
Easy:
Translate this method to a one liner using
streams and lambdas:
private static boolean isZeroInList(
List<BigDecimal> list) {
for (BigDecimal decimal : list) {
if (decimal.equals(BigDecimal.ZERO))
return true;
}
return false;
}
Medium: How might you format the code to make it
easier to read?

Intermediate Operations
filter(p -> p.isEmpty())
limit(3)
skip(2)
map(x -> x.size())
distinct()
sorted()
sorted((a,b) -> a.compareTo(b))
peek(x -> System.out.println(x))

Puzzle – Intermediate Operations
(10 mins)
Medium:
Using the puzzle 2 handouts, arrange so the
code prints: true false 3
UnaryOperator<Integer> op = x -> x + 1;
Predicate<Integer> pred = x -> x > 5;
boolean b1 = Stream.iterate(1, op). ______. ______;
boolean b2 = Stream.iterate(1, op)
. ______. ______. ______;
long l = Stream.generate(() -> 1). ______. ______;
System.out.println(b1 + " " + b2 + " " + l);
Challenge: Why are there two correct answers?

CountMatches.java
(10-15 mins)
Easy:
streams and lambdas: (expected output is 1 and 0)
private static long numberMatches(List<String> list) {
long count = 0;
for (String string : list) {
if (string.contains("g"))
count++;
}
return count;
}
Challenge: Refactor the code so you can pass the
lambda as a method parameter.

MoreLogic.java
(10 mins)
Medium:
Implement the method to print “walrus” using the logic
described:
public static void main(String[] args) {
List<String> matchingList = Arrays.asList(
"whale", "dolphin", "whale”, "manatee",
"orca", "walrus", "calf");
printMe(matchingList);
}
private static void printMe(List<String> list) {
// Print the third distinct element alphabetically
// that is over 4 characters long
}
Hard: Write “the old way”

Optional

Optional APIs

Optional Terminal Operations

Puzzle – Optional
Hard:
Using the puzzle 3 handouts, arrange so the
code prints: 1 2 -1
Optional<Integer> o1 = Stream.generate(() -> 1)
. ______;
Optional<Integer> o2 = Stream.iterate(1, x -> x + 1)
. ______. ______. ______;
Optional<Integer> o3 = Stream.iterate(1, x -> x + 1)
. ______. ______. ______;
System.out.println(o1.orElse(-1) + " "
+ o2.orElse(-1) + " " + o3.orElse(-1));
Challenge: Why are there four correct answers?

Collectors
• collect(Collectors.toList())
• collect(Collectors.toSet())
• collect(Collectors.toMap(
keyFunction, valueFunction))
• collect(Collectors.groupingBy(func))
• collect(Collectors.partitioningBy(func))
• collect(Collectors.joining())
• collect(Collectors.joining(”, "))

Printing a Stream

Squares.java
(5-10 mins)
Easy:
streams and lambdas:
private static List<String> convert(List<Integer> list) {
List<String> result = new ArrayList<>();
for (Integer number : list) {
if (number % 2 == 0)
result.add(number + "*" + number + "=" + (number *
number));
}
return result;
}
Challenge: Can you figure out how to make the return
type a LinkedList?

OddsAndEvens.java
(10 mins)
Medium:
Implement this method using streams and lambdas.
(Remember % is the modulus operator).
public static void main(String[] args) {
System.out.println(split(Arrays.asList(1, 4, 8,
13)));
System.out.println(split(Arrays.asList(1, 3)));
}
private static
Map<Boolean,List<Integer>> split(List<Integer> list) {
// partition the list into odds and evens
}
Hard: Change partioningBy to groupingBy. What’s the
difference?
Challenge: Implement this method without streams.

Method References
Infer lambdas by passing parameters for:
• Static methods
• Constructors
• Instance methods on the lambda param
• Instance methods on a particular instance

Static References
Java 7 new Consumer<List<Integer>>() {
public void accept(List<Integer> l) {
Collections.sort(l);
}
}
Lambda
l -> Collections.sort(l)
Method Reference
Collections::sort;

Constructor References
Java 7 new Supplier<ArrayList>() {
public ArrayList get() {
return new ArrayList();
}
}
Lambda
() -> new ArrayList()
Method Reference
ArrayList::new
Note: passing “zero length param list

Instance References
Java 7 new Predicate<String>() {
public boolean test(String s) {
return s.isEmpty();
}
}
Lambda s -> s.isEmpty()
Method Reference String::isEmpty

Instance References 2
Java 7 new Predicate<String>() {
public boolean test(String s) {
return str.startsWith(s);
}
}
Lambda
s -> str.startsWith(s)
Method Reference
str::startsWith
Assume: String str = "abc";

MethodReferencesFillInTheBlanks.java
(10-15 mins)
Easy: Fill in the blank to print with a lambda and method
reference.
Stream.of(“", "b", ”bc”).forEach(_________);
Hard: How many of these can you use a method
reference to fill in the blank? (the string is empty, the
string is not empty, the string ends with ‘c’)
Stream.of(“", "b", ”bc").filter(_________)

Next Steps to Learn
• Primitive streams
• Reduce()
• Summary Statistics
• Advanced collect()

Questions
?

java 8 Hands on Workshop

More Related Content

What's hot

Similar to java 8 Hands on Workshop

More from Jeanne Boyarsky

Recently uploaded

java 8 Hands on Workshop

Editor's Notes