Introduction toIntroduction toNew Features inNew Features in

Java 8Java 8Raffi Khatchadourian

Department of Computer Systems TechnologyNew York City College of Technology

City University of New YorkComputer Systems Technology Colloquium

March 26, 2015Based on slides by Duarte Duarte, Eduardo Martins, Miguel Marques and

Ruben Cordeiro and Horstmann, Cay S. (2014-01-10). Java SE8 for theReally Impatient: A Short Course on the Basics (Java Series). Pearson

Education.

Demonstration code at: .http://github.com/khatchad/java8-demo

Some HistorySome History

Java was invented in the 90's as an Object-Oriented language.Largest change was in ~2005 with Java 5.

Generics.Enhanced for loops.Annotations.Type-safe enumerations.Concurrency enhancements (AtomicInteger).

Java 8 is MassiveJava 8 is Massive

10 years later, Java 8 is packed with new features.Core changes are to incorporate functional language features.We can't cover everything today.Will focus on some of the more distributive features.

Functional LanguagesFunctional Languages

Declarative ("what not how").The only state is held in parameters.Traditionally popular in academia and AI.Well-suited for event-driven/concurrent ("reactive") programs.

Lambda ExpressionsLambda Expressions

A block of code that you can pass around so it can beexecuted later, once or multiple times.

Anonymous methods.Reduce verbosity caused by anonymous classes.

How are they different from Java methods?

LambdasLambdas(int x, int y) -> x + y

() -> 42

(String s) -> {System.out.println(s);}

LambdasLambdasExamplesExamples

BeforeBefore

Button btn = new Button();final PrintStream pStream = ...;btn.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent e) { pStream.println("Button Clicked!"); }});

AfterAfter

Button btn = new Button();final PrintStream pStream = ...;btn.setOnAction(e -> pStream.println("Button Clicked!"));

LambdasLambdasExamplesExamples

List<String> strs = ...;Collections.sort(strs, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

new Thread(() -> { connectToService(); sendNotification();}).start();

Functional InterfacesFunctional InterfacesSingle Abstract Method Type

Functional InterfacesFunctional InterfacesExampleExample

@FunctionalInterfacepublic interface Runnable { public void run();}

Runnable r = () -> System.out.println("Hello World!");

java.util.functionjava.util.functionPredicate<T> - a boolean-valued property of an objectConsumer<T> - an action to be performed on an objectFunction<T,R> - a function transforming a T to a RSupplier<T> - provide an instance of a T (such as a factory)UnaryOperator<T> - a function from T to TBinaryOperator<T> - a function from (T,T) to T

Method ReferencesMethod ReferencesTreating an existing method as an instance of a

Functional Interface

Method ReferencesMethod ReferencesExamplesExamples

class Person { private String name; private int age;

public int getAge() {return this.age;} public String getName() {return this.name;}}

Person[] people = ...;Comparator<Person> byName = Comparator.comparing(Person::getName);Arrays.sort(people, byName);

Method ReferencesMethod ReferencesKinds of method referencesKinds of method references

A static method (ClassName::methName)An instance method of a particular object(instanceRef::methName)A super method of a particular object (super::methName)An instance method of an arbitrary object of a particular type(ClassName::methName)A class constructor reference (ClassName::new)An array constructor reference (TypeName[]::new)

Method ReferencesMethod ReferencesMore ExamplesMore Examples

Consumer<Integer> b1 = System::exit;Consumer<String[]> b2 = Arrays::sort;Consumer<String> b3 = MyProgram::main;Runnable r = MyProgram::main;

Default MethodsDefault MethodsAdd default behaviours to interfaces

Why default methods?Why default methods?Java 8 has lambda expressions. We want to start using them:

List<?> list = ...list.forEach(...); // lambda code goes here

There's a problemThere's a problemThe forEach method isn’t declared by java.util.List nor thejava.util.Collection interface because doing so would break

existing implementations.

Default MethodsDefault MethodsWe have lambdas, but we can't force new behaviours into the current

libraries.Solution: default methods.

Default MethodsDefault MethodsTraditionally, interfaces can't have method definitions (justdeclarations).Default methods supply default implementations of interfacemethods.

ExamplesExamples

Example 1Example 1BasicsBasics

public interface A {

default void foo() { System.out.println("Calling A.foo()"); }}

public class Clazz implements A {}

Client codeClient code

Clazz clazz = new Clazz();clazz.foo();

OutputOutput

"Calling A.foo()"

Example 2Example 2Getting messyGetting messy

public interface A {

default void foo(){ System.out.println("Calling A.foo()"); }}

public interface B {

default void foo(){ System.out.println("Calling B.foo()"); }

}

public class Clazz implements A, B {}

Does this code compile?

Of course not (Java is not C++)!

class Clazz inherits defaults for foo() from both typesA and B

How do we fix it?

Option A:public class Clazz implements A, B { public void foo(){/* ... */}}

We resolve it manually by overriding the conflicting method.Option B:

public class Clazz implements A, B { public void foo(){ A.super.foo(); // or B.super.foo() }}

We call the default implementation of method foo() from eitherinterface A or B instead of implementing our own.

Going back to the example of forEach method, how can we force it'sdefault implementation all the iterable collections?

Let's take a look at the Java UML for all the iterable Collections:

In order to add a default behaviour to all the iterable collections, adefault forEach method was added to the Iterable<E> interface.

We can find its default implementation in java.lang.Iterableinterface:

@FunctionalInterfacepublic interface Iterable { Iterator iterator(); default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } }}

The forEach method takes a java.util.function.Consumerfunctional interface type as a parameter, which enables us to pass in a

lambda or a method reference as follows:List<?> list = ...list.forEach(System.out::println);

This is also valid for Sets and Queues, for example, since both classesimplement the Iterable interface.

SummarySummaryDefault methods can be seen as a bridge between lambdas and JDKlibraries.Can be used in interfaces to provide default implementations ofotherwise abstract methods.

Clients can optionally implement (override) them.static methods are now also allowed in interfaces.

Can eliminate the need for utility classes like .Collections

AccumulatorsAccumulatorsScalable updatable variables

AccumulatorsAccumulatorsThe continual evolution of uses of concurrency and parallelism in

applications requires continual evolution in library support. For thispurpose, the Accumulators were introduced.

AccumulatorsAccumulatorsMaintaining a single count, sum, etc., that is updated by possibly many

threads is a common scalability problem.A set of new classes were created for that purpose:

DoubleAccumulatorDoubleAdderLongAccumulatorLongAdder

AccumulatorsAccumulatorsPackage java.util.concurrent mechanisms synchronized

operations between threads, however if all you want to do is incrementa variable across threads, it was overkill and then some.

These classes are usually preferable to alternatives when multiplethreads update a common value that is used for purposes such as

summary statistics that are frequently updated but less frequently read.

AccumulatorsAccumulatorsBoth the DoubleAdder and LongAdder classes can be seen as specific

subsets of the DoubleAccumulator and LongAccumulatorfunctionality.

The call new DoubleAdder() is equivalent to:new DoubleAccumulator((x, y) -> x + y, 0.0).

The call new LongAdder() is equivalent to:new LongAccumulator((x, y) -> x + y, 0L).

ExamplesExamples

DoubleAccumulator da = new DoubleAccumulator((x,y) -> x + y, 0.0);List<Double> doubles = Arrays.asList(1.0, 2.0, 3.0, 4.0, 10.0);doubles.forEach(da::accumulate);

System.out.println("Result: " + da.doubleValue());

Output:Result: 20

LongAdder la = new LongAdder();List<Long> longs = Arrays.asList(10L, 20L, 30L, 40L, 100L);longs.forEach(la::add);

System.out.println("Result: " + la.longValue());

Output:Result: 200

java.util.streamjava.util.streamfilter/map/reduce for Java

java.util.streamjava.util.streamList<Student> students = …;Stream stream = students.stream(); // sequential version

// parallel versionStream parallelStream = students.parallelStream();

traversed onceinfinitelazy

java.util.streamjava.util.streamStream sourcesStream sources

CollectionsCollections

Set<Student> set = new LinkedHashSet<>();Stream<Student> stream = set.stream();

GeneratorsGenerators

Random random = new Random();Stream<Integer> randomNumbers = Stream.generate(random::nextInt);

From other streamsFrom other streams

Stream newStream = Stream.concat(stream, randomNumbers);

java.util.streamjava.util.streamIntermediate operationsIntermediate operations

.filter - excludes all elements that don’t match a Predicate

.map - perform transformation of elements using a Function

.flatMap - transform each element into zero or more elements byway of another Stream.peek - performs some action on each element.distinct - excludes all duplicate elements (equals()).sorted - orderered elements (Comparator).limit - maximum number of elements.substream - range (by index) of elementsList<Person> persons = ...;Stream<Person> tenPersonsOver18 = persons.stream() .filter(p -> p.getAge() > 18) .limit(10);

More examples at: .https://github.com/cst2301-pt13/library-solution

java.util.streamjava.util.streamTerminating operationsTerminating operations

1. Obtain a stream from some sources2. Perform one or more intermidate operations3. Perform one terminal operation

reducers like reduce(), count(), findAny(), findFirst()collectors (collect())forEachiterators

List<Person> persons = ..;List<Student> students = persons.stream() .filter(p -> p.getAge() > 18) .map(Student::new) .collect(Collectors.toList());

java.util.streamjava.util.streamParallel & SequentialParallel & Sequential

List<Person> persons = ..;List<Student> students = persons.stream() .parallel() .filter(p -> p.getAge() > 18) .sequential() .map(Student::new) .collect(Collectors.toCollection(ArrayList::new));

java.timejava.timeYet Another Java Date/Time API

java.timejava.timeCurrent TimeCurrent Time

Clock clockUTC = Clock.systemUTC();

Clock clockDefault = Clock.systemDefaultZone();

java.timejava.timeTime ZonesTime Zones

ZoneId zone = ZoneId.systemDefault();

ZoneId zoneBerlin = ZoneId.of("Europe/Berlin");Clock clock = Clock.system(zoneBerlin);

java.timejava.timeHuman Readable TimeHuman Readable Time

class LocalDate { public static LocalDate now() { ... } public static LocalDate now(ZoneId zone) { ... } public static LocalDate now(Clock clock) { ... }}

LocalDate date = LocalDate.now();System.out.printf("%s-%s-%s", date.getYear(), date.getMonthValue(), date.getDayOfMonth());

java.timejava.timeDoing CalculationsDoing Calculations

LocalTime lt = LocalTime.now();lt.plus(5, ChronoUnit.HOURS);

lt.plusHours(5);

Duration dur = Duration.of(5, ChronoUnit.HOURS);lt.plus(dur);

Documentation & InterestingDocumentation & InterestingLinksLinks

http://download.java.net/jdk8/docs/http://download.java.net/jdk8/docs/api/https://blogs.oracle.com/thejavatutorials/entry/jdk_8_documentation_developer_previewhttp://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Questions?Questions?