1. Computer Science 312
What’s New in Java 8? 1

2. What Is Pipelining?
Unix (or Linux) allows you to “pipe” data through a series of transformations using the | operator
Transformations:
Glue two files together
Convert the result to lowercase
Sort the resulting lines
Return the last three of those lines
cat file1 file2 | tr "[A-Z]" "[a-z]" | sort | tail -3

3. 21st Century Computing
Enormous amounts of data to be processed (“Big Data”)
Many CPUs are available, either via multicore or on a network
Would like a way of harnessing multiple processors to massage these data in a pipelined fashion, while using a simple, declarative style in our code

4. 21st Century Computing
In functional languages, data can be pipelined through a series of transformations, using a high- level, declarative style
Essential elements:
Map
Filter
Reduce (fold)
Lambda expressions

5. 21st Century Computing
Because functional languages forbid side effects, the work of these transformations can be dispatched to multiple processors
Essential elements:
Map
Filter
Reduce (fold)
Lambda expressions

6. What about the Rest of Us?
In most conventional languages, massaging data involves iterating through various types of collections to modify their elements; the style of this is anything but declarative
Although object orientation mitigates the potential for harmful side effects, programs in most conventional languages suffer the pitfalls of managing shared memory when resorting to concurrency

7. Java 8 to the Rescue!
Java 8, released in 2014, includes new features that allow programs to process data in a pipelined manner, across multiple CPUs, with a declarative style of code
The new features are
Streams (including parallel streams)
Methods (including lambdas) as arguments
Higher-order functions for mapping and filtering
Higher-order functions for collecting results

8. Sorting the Old-Fashioned Way
// java.util.Comparator
public interface Comparator<T> {
public int compare(T o1, T o2); }
// java.util.Collections.sort
static <T> void sort(List<T> list, Comparator<? super T> c)
Collections.sort supports the strategy pattern
Define a class that implements Comparator and pass an instance of this class to sort, for a particular type of comparison

9. Sorting the Old-Fashioned Way
// java.util.Comparator
public interface Comparator<T> {
public int compare(T o1, T o2); }
// java.util.Collections.sort
static <T> void sort(List<T> list, Comparator<? super T> c)
Collections.sort(inventory, new Comparator<Apple>() {
public int compare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight()); }
});
An instance of the strategy pattern
Clunky: must create an instance of an anonymous class

10. Generalized Sorting with a lambda
// java.util.Comparator
public interface Comparator<T> {
public int compare(T o1, T o2); }
// java.util.Collections.sort
static <T> void sort(List<T> list, Comparator<? super T> c)
inventory.sort(
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
Still a strategy, but we now pass an explicit behavior, without the extra fluff of a class definition
Much more declarative in style!

11. Filtering the Old-Fashioned Way

12. Filtering the Java 8 Way

13. Pass Method References
filterApples(inventory, Apple::isGreenApple);
filterApples(inventory, Apple::isHeavyApple);

14. Or Pass Lambda Expressions
filterApples(inventory, (Apple a) -> "green".equals(a.getColor()) );
filterApples(inventory, (Apple a) -> a.getWeight() > 150 );

15. Generalize to a filter Method
static <T> Collection<T> filter(Collection<T> c, Predicate<T> p){
// Build and return a collection of filtered results }
filter(inventory, (Apple a) -> "green".equals(a.getColor()) );
filter(inventory, (Apple a) -> a.getWeight() > 150 );
Could do this, but we won’t
Instead, we’ll create a stream from the collection, use the filter method in the java.util.stream API on this stream, and collect the results

16. Stream, Filter, and Collect
import static java.util.stream.Collectors.toList;
List<Apple> greenApples =
inventory.stream().filter((Apple a) -> "green".equals(a.getColor())
.collect(toList());
List<Apple> heavyApples =
inventory.stream().filter((Apple a) -> a.getWeight() > 150)
Instead, we’ll
create a stream from the collection
use the filter method in the java.util.stream API on this stream
collect the results

17. Filter and Group Transactions
Lots of control-flow (for and if statements)

18. Filter and Group Transactions
Drop control, use declarative style!

19. To Stream or to Parallel Stream?
Sequential stream:
import static java.util.stream.Collectors.toList;
List<Apple> heavyApples =
inventory.stream().filter((Apple a) -> a.getWeight() > 150)
.collect(toList());

20. To Stream or to Parallel Stream?
Sequential stream:
import static java.util.stream.Collectors.toList;
List<Apple> heavyApples =
inventory.stream().filter((Apple a) -> a.getWeight() > 150)
.collect(toList());
Parallel stream:
import static java.util.stream.Collectors.toList;
List<Apple> heavyApples =
inventory.parallelStream().filter((Apple a) -> a.getWeight() > 150)
.collect(toList());

21. Other Cool Stuff in Java 8
Default methods – can include method implementations in an interface, so implementers of its classes won’t go crazy when new methods are added
Optional types – no more null pointer exceptions, due to having to return either null or some full- fledged object; specifies the Optional<T> type with accessor methods

22. Lambda expressions in Java Chapter 3
For next time
Lambda expressions in Java
Chapter 3