new features in jdk 8
DESCRIPTION
Presentation on the new features introduced in JDK 8, presented on the 26.02.2013 in Sofia University in front of students and members of the Bulgarian java user group.TRANSCRIPT
New Features in JDK 8
Ivan St. IvanovDmitry AlexandrovMartin Toshev
Agenda
• Lambda Expressions
• Other New Features in JDK 8
• JEPs and JDK 9 Development
Lambda Expressions
Lambdas
• Lambdas bring anonymous function types in Java (JSR 335):
• Example:
(x,y) -> x + y
(parameters) -> {body}
Lambdas
• Lambdas bring anonymous function types in Java
• Example:
… well … Groovy (a superset of java) already provides this …
(x,y) -> x + y
(parameters) -> {body}
Lambdas
• Lambdas can be used in place of functional interfaces (interfaces with just one method such as Runnable)
• Example:new Thread(new Runnable() {
@Overridepublic void run() {
System.out.println("It runs !"); }}).start();
new Thread(() -> { System.out.println("It runs !"); }).start();
Lambdas
• Examples of such functional interfaces:
java.lang.Runnable -> run() java.util.concurrent.Callable -> call() java.security.PrivilegedAction -> run() java.util.Comparator -> compare(T o1, T o2) java.awt.event.ActionListener ->
actionPerformed (ActionEvent e) java.lang.Iterable ->
forEach(Consumer<? super T> action)
Lambdas
java.lang.Iterable -> forEach(Consumer<? super T> action) ?!?
Isn't this breaking backward compatibility ?!?
Lambdas
java.lang.Iterable -> forEach(Consumer<? super T> action) ?!?
Isn't this breaking compatibility ?!?
No - because forEach is an extension method.
Lambdas
Extension methods provide a mechanism for extending an existing interface without breaking backward compatibility.
public interface Iterable<T> {
default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } }}
Lambdas
• This essentially means that lambdas can be used to replace all functional interfaces used in a gazillion of libraries
• Moreover lambdas increase performance when used instead of anonymous inner classes because they are implemented with the invokedynamic instruction
• In this regard many of the standard JDK class are being refactored to use lambdas
Lambdas
• Additional functional interfaces are provided by the java.util.function package for use by lambdas such as:o Predicate<T> - one method with param of type T and
boolean return typeo Consumer<T> - one method with param T and no
return typeo Function<T, R> - one method with param T and return
type Ro Supplier<T> - one method with no params and return type T
Stream API
• Databases and other programming languages allow us to specify aggregate operations explicitly
• The streams API provides this mechanism in the Java platform
• The notion of streams is derived from functional programming languages
Stream API
• The stream API makes use of lambdas and extension methods
• Streams can be applied on collections, arrays, IO streams and generator functions
Stream API
• Streams can be finite or infinite
• Streams can apply intermediate functions on the data that produce another stream (e.g. map, reduce)
Stream API
java.util.stream.Stream<T> collection.stream();java.util.stream.Stream<T> collection.parallelStream();Useful methods:
o filter(Predicate), map(Function), reduce(BinaryOperator), collect()
o sum(), min(), max(), count()o anyMatch(), allMatch(), forEach(),
Stream internals
• Stream operations are composed into a pipeline
• Streams are lazy: computation is performed when the terminal operation is invoked
int sum = widgets.stream() .filter(w -> w.getColor() == RED) .mapToInt(w -> w.getWeight()) .sum();
Method references
• Intended to be used in lambda expressions, preventing unnecessary boilerplate
• Example:
• Lambda parameter list and return type must match the signature of the method
books.stream().map(b -> b.getTitle()) books.stream().map(Book::getTitle)
Method references – static methods
public class Printers { public static void print(String s) {...} }
Arrays.asList("a", "b", "c").forEach(Printers::print)
Method references – instance methods (1)
public class Document { public String getPageContent(int pageNumber) { return this.pages.get(pageNumber).getContent(); }}
public static void printPages(Document doc, int[] pageNumbers) { Arrays.stream(pageNumbers) .map(doc::getPageContent) .forEach(Printers::print); }
Method references – instance methods (2)
public class Document { public String getPageContent(int pageNumber) { return this.pages.get(pageNumber).getContent(); }}
public static void printDocuments(List<Page> pages) { pages.stream() .map(Page::getContent) .forEach(Printers::print); }
Method references – constructors
public static Stream<Page> createPagesFrom(Stream<String> contents) { return contents.map(Page::new). }
Lambda Expressions:Hands-On-Lab
Lambdas Hands-on-Lab:Overview
• Environment setup
• Concept
• Task categories
Lambdas Hands-on-Lab:Environment Setup
• Download and install OpenJDK 8 early access
build from https://jdk8.java.net/lambda/ (… or build yours from the OpenJDK repo)
Lambdas Hands-on-Lab:Environment Setup
• Download and install an IDE:
o Eclipsehttp://www.oracle.com/technetwork/articles/java/lambda-1984522.html(for Eclipse 4.3: Start IDE -> Install New Software)http://build.eclipse.org/eclipse/builds/4P/siteDir/updates/4.3-P-builds
o IntelliJ IDEA CEhttp://www.jetbrains.com/idea/free_java_ide.html
Lambdas Hands-on-Lab:Environment Setup
• Get the sources:
or download
• Import the sources as Maven projects in the IDE• Set the Java 8 profile (source compatibility level)• Check if the sources compile and that you are able to run
ConfigureYourLambdaBuildOfJdk
git clone https://github.com/AdoptOpenJDK/lambda-tutorial
http://dmitryalexandrov.net/lambda.zip
Lambdas Hands-on-Lab:Concept
• We have several classes and tests for them
• Find “// your code here” and write the code !
• Run the tests. Try to make them green!(… read the comments.. They are useful !)
Lambdas Hands-on-Lab:Task Categories
• Internal vs External Iteration
• Filtering and Collecting
• Mapping
• Method References
Lambdas Hands-on-Lab:Internal vs External Iteration
Java 8 (Internal)
myShapes.forEach(shape -> shape.setColor(RED));
Java 7 (External)
for (Shape shape: myShapes) { shape.setColor(RED);
}
Lambdas Hands-on-Lab:Filtering and Collecting
Java8otherThings.stream()
.filter(s -> satisfiesSomeCondition(s))
.collect(Collectors.toList());
Java7for (String s: otherThings) {
if (satisfiesSomeCondition(s)) { things.add(s);
}}
Lambdas Hands-on-Lab:Mapping
Java8mixedCaseStrings.stream()
.map(s -> s.toUpperCase()) .collect(Collectors.toList());
Java7List<String> upperCaseStrings = new ArrayList<>();for (String s: mixedCaseStrings) {
upperCaseStrings.add(s.toUpperCase());}
Lambdas Hands-on-Lab:Mapping
Using a lambda expression:
myStrings.map(s -> s.toUpperCase());
Using a method reference:
myStrings.map(String::toUpperCase);
Can be used with:• Static methods belonging to a particular class (<class>::<staticMethod>)• Instance methods bound to a particular object instance (<obj> ::
<instanceMethod>)• Instance methods bound to a particular class (<class> :: <instanceMethod>)• Constructor belonging to a particular class (<class> :: new)
Lambdas Hands-on-Lab:Default Methods
Java 8
public interface A { default void foo(){ System.out.println("Calling A.foo()"); }}
public class Clazz implements A {}
Clazz clazz = new Clazz();clazz.foo(); // Calling A.foo()
Lambdas Hands-on-Lab:Default Methods
Java 8
public class Clazz2 implements A { @Override public void foo(){ System.out.println("Calling A.foo()"); }}
Clazz2 clazz2 = new Clazz2();clazz2.foo(); // Calling A.foo()
Lambdas Hands-on-Lab:Let's have some fun
Lambdas Hands-on-Lab:Hints
Examples:1. (int x, int y) -> x + y2. (x, y) -> x - y3. () -> 42 4. (String s) -> System.out.println(s)5. x -> 2 * x6. c -> { int s = c.size(); c.clear(); return s; }7. myShapes.forEach(shape -> shape.setColor(RED));8. otherThings.stream().filter(s -> satisfiesSomeCondition(s)).collect(Collectors.toList());9. mixedCaseStrings.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());10. myStrings.map(String::toUpperCase); 11. public interface A { default void foo(){ System.out.println("Calling A.foo()");} }
The basic syntax of a lambda is either (parameters) -> expressionor (parameters) -> { statements; }
Other New Features in JDK 8
Date and Time API (JSR 310)
• Provides a new date, time and calendar API for the Java SE platform
• Examples:Clock clock = Clock.systemUTC();ZoneId zone = ZoneId.systemDefault();ZoneId customZone = ZoneId.of("Europe/Berlin");Clock customClock = Clock.system(customZone);DateTimeFormatter formatter = DateTimeFormatter.
ofPattern("MM-DD-YYYY");LocalDate date = LocalDate.now();String formattedDate = date.format(formatter);System.out.println(formattedDate);
Nashorn (via JSR 223)
• Nashorn is a JavaScript engine developed in the Java language
• A command line tool (jjs) for running javascript without using Java is also provided
Nashorn (via JSR 223)
• Nashorn is a JavaScript engine developed in the Java language
• A command line tool (jjs) for running javascript without using Java is also provided
• … well … JDK 6 is already shipped with Mozilla's Rhino JavaScript engine but is slower …
Nashorn (via JSR 223)
• Example (calling JavaScript from Java):
ScriptEngineManager m = new ScriptEngineManager();ScriptEngine nashorn = m.getEngineByName("nashorn");try {
nashorn.eval("print('Hello, world')");} catch (ScriptException e) {}
Nashorn (via JSR 223)
• Example (calling Java from JavaScript):
var ExampleType = Java.type("com.sample.Example");var example = new ExampleType("arg");print(example.method())
Parameter Names (JEP 118)
• Parameter names for method/constructor parameters can be retrieved at runtime via reflection
Method method = …Parameter param = method.getParameters()[0];System.out.println(param.getName());
Annotation on Java Types (JSR 308, JEP 104)
• Extend the set of annotatable locations in the syntax of the Java programming language
• Allow type checkers in the form of compiler plug-ins to provide stronger type checking
• Sample annotations: @notnull, @readonly
• Enhancements to JSR 269 (Pluggable Annotation Processing API)
Repeating Annotations(JEP 120)
• Change the Java programming language to allow multiple annotations with the same type on a single program element
Base64 Encoding/Decoding(JEP 135)
• Defines a standard API for Base64 encoding and decoding:java.util.Base64.Encoderjava.util.Base64.Decoder
Concurrency Updates(JEP 155)
• Scalable updatable variables (for frequent updates from multiple threads) are part of the concurrency updates:java.util.concurrent.atomic.DoubleAccumulatorjava.util.concurrent.atomic.DoubleAdderjava.util.concurrent.atomic.LongAccumulatorjava.util.concurrent.atomic.LongAdder
Compact Profiles(JEP 161)
• Defines a few subset Profiles of the Java SE Platform Specification so that applications that do not require the entire Platform can be deployed and run on small devices.
• Currently three profiles: o compact1o compact2o compact3
Other
• Prepare for modularization (JEP 162) - changes and deprecation of APIs to prepare for the modularization of the platform as undertaken by project Jigsaw
• Permanent generation space removed - objects from this space such as class metadata, static variables and interned strings moved to heap space
(improved convergence between OpenJDK and Oracle's JRockit)
Some books
JEPs and JDK 9 Development
JEPs and JDK 9 Development
So lets see what JEPs are left for JDK 9 ->http://openjdk.java.net/jeps/
Q&A
References
OpenJDK 8 early access buildshttps://jdk8.java.net/
Oracle JDK 8 early access buildshttp://www.oracle.com/technetwork/java/javase/downloads/ea-jsp-142245.html
Eclipse with JDK 8 supporthttps://wiki.eclipse.org/JDT_Core/Java8
References
OpenJDK mercurial repositorieshttp://hg.openjdk.java.net/
OpenJDK 9 build instructionshttp://hg.openjdk.java.net/jdk9/jdk9/raw-file/tip/README-builds.html
JSR 337: Java SE 8 (Early Draft Review Specification)http://cr.openjdk.java.net/~mr/se/8/java-se-8-edr-spec.html
References
Lambda tutorialhttps://github.com/AdoptOpenJDK/lambda-tutorial
State of the Lambdahttp://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html
Lambda FAQhttp://www.lambdafaq.org/
References
Java SE tutorials: Lambda Expressionshttp://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
Lambda Quick Start Guidehttp://www.oracle.com/webfolder/technetwork/tutorials/obe/java/Lambda-QuickStart/index.html
Java Enhancement Proposalshttp://openjdk.java.net/jeps