Java 8 - An Introduction by Jason Swartz

Java 8
An Introduction by
Jason Swartz

Agenda
1. Lambda Expressions
2. Streaming Collections
3. Monadic Collections

Java Function
int sqr(int x) { return x * x; }

Java Anonymous Function
x -> x * x

(x) -> x * x

(x, y) -> x + y

() -> 42

f = x -> x * x;
int y = f.apply(5);

f = (x, y) -> x + y;
int y = f.applyAsInt(5, 7);

r = () -> {
System.out.println("Hello");
};
r.run();

Java Method Reference
c = System.out::println;
c.accept("Hello");

Doubling Items In A List
List<Integer> nums = Arrays
.asList(1, 2, 3);
int sqr(int x) { return x * x; }

nums2 = new ArrayList<Integer>();
for (int i : nums) {
nums2.add(sqr(i));
}

nums.stream()

nums.stream()
.map(this::sqr)

nums = nums.stream()
.map(this::sqr)
.collect(Collectors.toList());

.map(x -> x * x)

nums = nums.parallelStream()
.map(x -> x * x)

nums = nums.clusterStream()
.map(x -> x * x)

nums = nums.dataCenterStream()
.map(x -> x * x)

Welcome to
Declarative
Programming

Mapping To A List of Lists
nums.stream()
.map(x -> Arrays.list(x, x * x))

Flatmap That List
.flatMap(x -> Arrays.list(x, x * x))

Filtering Items In A List
.filter(x -> x % 2 == 0)

Reducing A List
sum = nums.stream()
.reduce((a,i) -> a + i)
.get();

In Summary
sum = nums.stream()
.map(x -> x * x)
.flatMap(x -> Arrays.list(x, x * x))
.filter(x -> x % 2 == 0)
.reduce((a,i) -> a + i)
.get();

map()
flatmap()
reduce()
filter()

Have you done this?
User u = getUser(“Fred”);
String name = u.getName();
Exception in thread "main" java.lang.
NullPointerException

Use Optional<T>, not null
Optional<User> u = getUser("Fred");
if (! u.isPresent()) return;
String name = u.get().name;

Use Optional<T>, not null
Optional<String> name = u
.map(user -> user.name);

Checking a user name
User u = getUser(“Fred”);
Boolean result = null;
if (u != null)
Result = checkName(u.getName());
else
Result = false;

Checking a user name
Boolean result;
if (u.isPresent())
result = confirmName(u.get().name);
else
result = false;

Confirming a user name with map()
Boolean result = getUser("Fred")
.map(u -> u.name)
.map(this::confirmName)
.orElse(false);

Optional is just a monad, a
monoid in the category of
endofunctors.
What’s the problem?

Optional is a zero- or one-
sized collection that helps
you cleanly handle
missing values.

CompletableFuture is a
zero- or one-sized
collection that helps you
cleanly handle future
values.

Javaslang’s Try is a zero-
or one-sized collection that
helps you cleanly handle
exception-thrown values.

Javaslang’s Lazy is a zero-
or one-sized collection that
helps you cleanly postpone
calculating values.

Now You Know
Monadic Collections

More Related Content