Mohsen Zainalpour What`s New in Java 8 JUG

2012/04/26M1 2012/06/14M2 2012/08/02M3 2012/09/13M4 2012/11/29M5 2013/01/31M6 2013/06/13M7Feature Complete 2013/09/05M8Developer Preview 2014/01/23M9Final Release Candidate 2014/03/18GAGeneral Availability JDK 8 Schedule and status

Major changes Agenda JUG Why is Java still changing? Type Annotations Lambda Project Date and Time API Compact Profiles

Java 8 Is Revolutionary, Java Is Back “ Lambda is the single largest upgrade to the programming model. Ever. It's larger even than Generics. It's the first time since the beginning of Java that we've done a carefully coordinated co-evolution of the virtual machine, the language and the libraries, all together. Yet the result still feels like Java. Mark Reinhold ( Chief Architect of the Java Platform Group at Oracle )

Java 8 Is Revolutionary, Java Is Back “ Lambda is the single largest upgrade to the programming model. Ever. It's larger even than Generics. It's the first time since the beginning of Java that we've done a carefully coordinated co-evolution of the virtual machine, the language and the libraries, all together. Yet the result still feels like Java. Mark Reinhold ( Chief Architect of the Java Platform Group at Oracle )

Lambda JSR 335

Why is Java still changing?

The changing computing background Increasingly dealing with big data (terabytes and up) and wishing to exploit multicore computers or computing clusters effectively to process this. And this means using: parallel processing parallel processing big datamulticore cloud computing

The Progress of Programming There`s been a lot of progress & Progress is being allowed to forget things!

The Progress of Programming There`s been a lot of progress: -Assemblers let us forget opcodes

The Progress of Programming There`s been a lot of progress: -Assemblers let us forget opcodes -Garbage collections let us forget memory management #include int main () { … buffer = (char*) malloc (i+1); … free (buffer); … }

The Progress of Programming So what about parallelism?

Why Can`t We Forget About Parallelism? Most of parallelism problems are doing bulk operations on collection and we keep writing code like this: int sum = 0; for (int i = 0; i < a.length; i++) { sum += a[i]; } int sum = 0; for (int i = 0; i < a.length; i++) { sum += a[i]; }  It is inherently serial

Why Can`t We Forget About Parallelism? If the processing of different elements is to proceed in parallel, it is the responsibility of the client code

Why Can`t We Forget About Parallelism? If the processing of different elements is to proceed in parallel, it is the responsibility of the client code n1n2n3n4n5n6n7n8n9………… sum1 sum2 sum3sum4

Why Can`t We Forget About Parallelism? If the processing of different elements is to proceed in parallel, it is the responsibility of the client code n1n2n3n4n5n6n7n8n9………… class Sum implements Callable { private final long from; private final long to; Sum(long from, long to) { this.from = from; this.to = to; } public Long call() { long acc = 0; for (long i = from; i <= to; i++) { acc = acc + i; } return acc; } sum1 sum2 sum3sum4

Why Can`t We Forget About Parallelism? If the processing of different elements is to proceed in parallel, it is the responsibility of the client code n1n2n3n4n5n6n7n8n9………… sum1 sum2 sum3sum4 ExecutorService executor = Executors.newFixedThreadPool(2); List > results = executor.invokeAll(asList( new Sum(1, 250), new Sum(251, 500), new Sum(551, 750), new Sum(751, 1000) )); for (Future result : results) { System.out.println(result.get()); }

Why Can`t We Forget About Parallelism? Sequential Parallel (assuming a quad core machine) Time t Thread 1 Thread 2 Thread 3 Thread 4 Done parallel Done sequential

Why Can`t We Forget About Parallelism? Let the Library Writers do it! Collection developers know the recursive structure of their data But right now they can`t use that knowledge

Why Can`t We Forget About Parallelism? Let the Library Writers do it! Collection developers know the recursive structure of their data But right now they can`t use that knowledge int sum = 0; for (Iterator itr = myList.iterator();itr.hasNext(); ) { sum += itr.next(); } int sum = 0; for (Iterator itr = myList.iterator();itr.hasNext(); ) { sum += itr.next(); } The problem is external iteration

Why Can`t We Forget About Parallelism? Internal Iteration Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; } Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; }

Why Can`t We Forget About Parallelism? Internal Iteration We`re going to write this: int [] sum = new int[1]; myList.forEach( … ); We`re going to write this: int [] sum = new int[1]; myList.forEach( … ); Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; } Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; }

Why Can`t We Forget About Parallelism? Internal Iteration Let the collection choose its iteration strategy - Parallel, serial, out-of-order, lazy, … We`re going to write this: int [] sum = new int[1]; myList.forEach( … ); We`re going to write this: int [] sum = new int[1]; myList.forEach( … ); Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; } Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; }

Why Can`t We Forget About Parallelism? Internal Iteration Let the collection choose its iteration strategy - Parallel, serial, out-of-order, lazy, … We`re going to write this: int [] sum = new int[1]; myList.forEach( a -> sum[0]+=a ); We`re going to write this: int [] sum = new int[1]; myList.forEach( a -> sum[0]+=a ); Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; } Instead of this: int sum = 0; for (int i=0;i<myList.size();i++){ int a=myList.get(i); sum+=a; }

Why Can`t We Forget About Parallelism? a -> sum[0]+=a

Lambda Project – JSR 335 JSR 335 (Lambda Project) aims to support programming in a multicore environment by adding closures and related features to the Java language.

What are Lambda Expressions (closures)? A lambda expression :

What are Lambda Expressions (closures)? is an anonymous method A lambda expression :

What are Lambda Expressions (closures)? is an anonymous method having an argument list A lambda expression : a ->

What are Lambda Expressions (closures)? is an anonymous method having an argument list a return type A lambda expression : a ->

What are Lambda Expressions (closures)? is an anonymous method having an argument list a return type and a body A lambda expression : a -> sum[0]+=a

What are Lambda Expressions (closures)? is an anonymous method having an argument list a return type and a body A lambda expression : sum[0] a -> sum[0]+=a and able to refer to values from the enclosing scope (closure)

What are Lambda Expressions (closures)? is an anonymous method having an argument list a return type and a body A lambda expression : sum[0] a -> sum[0]+=a and able to refer to values from the enclosing scope (closure) To pass behavior to the API as data

From Single Method Interface …. public interface Comparator { }

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); }

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); } Single Abstract Method (SAM)

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); } Single Abstract Method (SAM) Functional Interface

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); } Collections.sort(strings, new Comparator () { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } });

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); } Collections.sort(strings, new Comparator () { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } });

From Single Method Interface …. public interface Comparator { int compare(T o1, T o2); } Collections.sort(strings, new Comparator () { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } });  Bulky syntax  Confusion surrounding the meaning of names and this

… To Lambda Expressions Collections.sort(strings, (s1, s2) -> s1.compareToIgnoreCase(s2));

… To Lambda Expressions Collections.sort(strings, (s1, s2) -> s1.compareToIgnoreCase(s2));

… To Lambda Expressions Collections.sort(strings, (s1, s2) -> s1.compareToIgnoreCase(s2)); Lambda expression are always converted to instance of a functional interface Comparator c = (s1, s2) -> s1.compareToIgnoreCase(s2)); No need of changing the JVM to create a new type for lambda expressions

… To Lambda Expressions Collections.sort(strings, new Comparator () { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } }); Collections.sort(strings, (s1, s2) -> s1.compareToIgnoreCase(s2) );

… To Lambda Expressions Collections.sort(strings, new Comparator () { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } }); Collections.sort(strings, (s1, s2) -> s1.compareToIgnoreCase(s2) );

Without more language support for parallel idioms, people will instinctively reach for serial idioms

External Iteration Sum of squares long sum = 0L; for (long i = 0; i < N; i++) { sum += i * i; }

Internal Iteration Sum of squares long sum = LongStream.range(0, N).map(i -> i * i).sum();

Internal Iteration Going parallel long sum = LongStream.range(0, N).parallel().map(i -> i * i).sum();

Parallel Streams A behavioral parameter (lambda) may be invoked concurrently – This constraint gives us “wiggle room” to optimize

Up the level of abstraction External iteration conflates what with howInternal iteration: more what; less howClient passes behavior to the API as dataLibrary is free to use Multiple threads Out-of- order execution Laziness

Lambdas in Java 8 Lambda Code as data (Simplicity) Multi-core processing / parallel processing Interface evolution Bulk data operations

Lambdas in Java 8

Date and Time API JSR 310

New Date and Time API History of Java Date/Time APIs Java.util.Date, java.util.Calendar -Strong candidates for the all-time worst Java platform library design Joda Time -Quality date and time library JSR Builds on experience of Joda Time

New Date and Time API Design Principles Immutable - Thread-safe, allows caching Fluent - easy to read, like a DSL LocalDate.of(2013,Month.JANUARY,09).withYear(2014);

New Date and Time API Time for Humans Field-base, designed for humans -Year,month,day,hour,minute,second -LocalDate,LocalDateTime,ZonedDateTime,Period …

New Date and Time API London 12:50 Los Angeles 16:20

New Date and Time API void flightTime() { LocalDate date = LocalDate.of(2013, Month.SEPTEMBER, 14); LocalTime takeoff = LocalTime.of(12, 50); LocalTime landing = LocalTime.of(16, 20); ZoneId LHR = ZoneId.of("Europe/London"); ZoneId SFO = ZoneId.of("America/Los_Angeles"); Duration flightTime = Duration.between( ZonedDateTime.of(date, takeoff, LHR), ZonedDateTime.of(date, landing, SFO)); System.out.println("Flight time: " + flightTime); }

Annotations JSR 308

Type Annotations  JSR-308 brings annotations on Type use  Are an enabler for the checkers framework Ex.: MyObject(); myString = String) myObject; void monitorTemperature() TemperatureException {... }

Repeating Annotations  ({ hour="23") )} public void doPeriodicCleanup() {... }

Repeating Annotations  ({ hour="23") )} public void doPeriodicCleanup() {... } hour="23") public void doPeriodicCleanup() {... }

Java SE 8 Compact Profiles

SE Full JRE Hotspot VM Lang & Util Base Libraries Other Base Libraries Integration Libraries UI & Toolkits Optional Components Hotspot VM Base Compact1 Classes SE 8 Compact Profiles Compact2 Class libraries Compact3 Class libraries 1 2 3

Q&A

References Lambda (slides: mainstream-programmi?newsletter=1&nlcode=29983% 7c903a * Collections

References Remove the Permanent Generation JSR 310: Date and Time API General Java

References Annotations