introduction to new features in java 8
Upload: new-york-city-college-of-technology-computer-systems-technology-colloquium
Post on 14-Jul-2015
353 views
TRANSCRIPT
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.
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.
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 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;
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.
public interface A {
default void foo() { System.out.println("Calling A.foo()"); }}
public class Clazz implements A {}
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
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).
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.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.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