This document discusses new features in JDK 8 including lambda expressions, method references, default methods in interfaces, date and time API improvements, Nashorn JavaScript engine, parameter names in reflection, and annotation improvements. It also briefly mentions JEPs and upcoming features for JDK 9 such as modularity. The presenter provides code examples and explanations for many of the new JDK 8 language and API features.

1. New Features in JDK 8
Mohamed Taman @_tamanm
Enterprise Architect / Innovation & R&D Sr. Manager @efinance
Java Champions, International Speaker, Author, EGJUG Board
member, MoroccoJUG member.

3. Reach me on
@_tamanm
http://eg.linkedin.com/in/mohamedtaman/
https://www.facebook.com/mohamed.m.taman.7
(Mohamed Mahmoud Taman)
http://tamanmohamed.blogspot.com

4. Agenda
• Lambda Expressions
• Other New Features in JDK 8
• JEPs and JDK 9 Development

5. Lambda Expressions

6. Lambdas
• Lambdas bring anonymous function types in Java
(JSR  java specification request 335):
• Example:
• This is a method -- (x,y) -> x + y
(parameters) -> {body}

7. Lambdas
• Lambdas bring anonymous function types in Java
• Example:
… well … Groovy (a superset of java) already provides this …
(x,y) -> x + y
(parameters) -> {body}

8. Lambdas
• Lambdas can be used in place of functional interfaces (interfaces
with just one method such as Runnable)
• Example:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("It runs !");
}
}
).start();
new Thread(() ->
{ System.out.println("It runs !"); }
).start();

9. 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)

10. Lambdas
java.lang.Iterable ->
forEach(Consumer<? super T> action) ?!?
Isn't this breaking backward compatibility ?!?

11. Lambdas
java.lang.Iterable ->
forEach(Consumer<? super T> action) ?!?
Isn't this breaking compatibility ?!?
No - because forEach is an extension method.

12. 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);
}
}
}

13. 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.

14. 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 type
o Consumer<T> - one method with param T and no
return type
o Function<T, R> - one method with param T and return
type R
o Supplier<T> - one method with no params and
return type T

15. 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

16. Stream API
• The stream API makes use of lambdas and extension methods
• Streams can be applied on collections, arrays, IO streams and
generator functions

17. Stream API
• Streams can be finite or infinite
• Streams can apply intermediate functions on the data that
produce another stream (e.g. map, reduce)

18. 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(),

19. 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();

20. 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)

21. Method references – static methods
public class Printers {
public static void print(String s) {...}
}
Arrays.asList("a", "b", "c").forEach(Printers::print)

22. 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);
}

23. 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);
}

24. Method references – constructors
public static Stream<Page>
createPagesFrom(Stream<String> contents) {
return contents.map(Page::new).
}

25. Lambda Expressions:
Hands-On-Lab

26. Lambdas Hands-on-Lab:
Overview
• Environment setup
• Concept
• Task categories

27. 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)

28. Lambdas Hands-on-Lab:
Environment Setup
• Download and install an IDE:
o Eclipse
http://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 CE
http://www.jetbrains.com/idea/free_java_ide.html

29. 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

30. 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 !)

31. Lambdas Hands-on-Lab:
Task Categories
• Internal vs External Iteration
• Filtering and Collecting
• Mapping
• Method References

32. 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);
}

33. Lambdas Hands-on-Lab:
Filtering and Collecting
Java8
otherThings.stream()
.filter(s -> satisfiesSomeCondition(s))
.collect(Collectors.toList());
Java7
for (String s: otherThings) {
if (satisfiesSomeCondition(s)) {
things.add(s);
}
}

34. Lambdas Hands-on-Lab:
Mapping
Java8
mixedCaseStrings.stream()
.map(s -> s.toUpperCase())
.collect(Collectors.toList());
Java7
List<String> upperCaseStrings = new ArrayList<>();
for (String s: mixedCaseStrings) {
upperCaseStrings.add(s.toUpperCase());
}

35. 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)

36. 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()

37. 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()

38. Lambdas Hands-on-Lab:
Let's have some fun

39. Lambdas Hands-on-Lab:
Hints
Examples:
1. (int x, int y) -> x + y
2. (x, y) -> x - y
3. () -> 42
4. (String s) -> System.out.println(s)
5. x -> 2 * x
6. 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) -> expression
or
(parameters) -> { statements; }

40. Other New Features in JDK 8

41. 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);

42. 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

43. 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 …

44. 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) {
}

45. Nashorn (via JSR 223)
• Example (calling Java from JavaScript):
var ExampleType = Java.type("com.sample.Example");
var example = new ExampleType("arg");
print(example.method())

46. 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());

47. 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)

48. Repeating Annotations
(JEP 120)
• Change the Java programming language to allow
multiple annotations with the same type on a
single program element

49. Base64 Encoding/Decoding
(JEP 135)
• Defines a standard API for Base64 encoding and
decoding:
java.util.Base64.Encoder
java.util.Base64.Decoder

50. Concurrency Updates
(JEP 155)
• Scalable updatable variables (for frequent
updates from multiple threads) are part of the
concurrency updates:
java.util.concurrent.atomic.DoubleAccumulator
java.util.concurrent.atomic.DoubleAdder
java.util.concurrent.atomic.LongAccumulator
java.util.concurrent.atomic.LongAdder

51. 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 compact1
o compact2
o compact3

52. 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)

53. Some books

54. JEPs and JDK 9 Development

55. JEPs and JDK 9 Development
So lets see what JEPs are left for JDK 9 ->
http://openjdk.java.net/jeps/

56. Q&A

57. References
OpenJDK mercurial repositories
http://hg.openjdk.java.net/
OpenJDK 9 build instructions
http://hg.openjdk.java.net/jdk9/jdk9/raw-file/tip/README-
builds.html

58. References
Lambda tutorial
https://github.com/AdoptOpenJDK/lambda-tutorial
State of the Lambda
http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-
final.html
Lambda FAQ
http://www.lambdafaq.org/

59. References
Java SE tutorials: Lambda Expressions
http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.h
tml
Lambda Quick Start Guide
http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/Lamb
da-QuickStart/index.html
Java Enhancement Proposals
http://openjdk.java.net/jeps