The document discusses the new features introduced in JDK 8, primarily focusing on lambda expressions, the Stream API, method references, and the new date and time API. It emphasizes the performance improvements and enhancements in Java's functionality through these features, including how they allow for more efficient coding practices. Additionally, the document provides insights into hands-on labs, setup requirements for learning about lambda expressions, and other enhancements present in JDK 8.

1. New Features in JDK 8
Ivan St. Ivanov
Dmitry Alexandrov
Martin Toshev

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

3. Lambda Expressions

4. Lambdas
• Lambdas bring anonymous function types in Java
(JSR 335):
(parameters) -> {body}
• Example:
(x,y) -> x + y

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

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

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

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

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

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

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

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

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

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

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

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

17. Stream internals
int sum = widgets.stream()
.filter(w -> w.getColor() == RED)
.mapToInt(w -> w.getWeight())
.sum();
• Stream operations are composed into a pipeline
• Streams are lazy: computation is performed when
the terminal operation is invoked

18. Method references
• Intended to be used in lambda expressions,
preventing unnecessary boilerplate
• Example:
books.stream().map(b -> b.getTitle()) 
books.stream().map(Book::getTitle)
• Lambda parameter list and return type must
match the signature of the method

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

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

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

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

23. Lambda Expressions:
Hands-On-Lab

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

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

26. Lambdas Hands-on-Lab:
Environment Setup
•
Download and install an IDE:
o Eclipse
http://www.oracle.com/technetwork/articles/java/lambda1984522.html
(for Eclipse 4.3: Start IDE -> Install New Software)
http://build.eclipse.org/eclipse/builds/4P/siteDir/updates/4.3-Pbuilds
o IntelliJ IDEA CE
http://www.jetbrains.com/idea/free_java_ide.html

27. Lambdas Hands-on-Lab:
Environment Setup
•
Get the sources:
git clone https://github.com/AdoptOpenJDK/lambda-tutorial
or download
• Import the sources as Maven projects in the IDE
http://dmitryalexandrov.net/lambda.zip
• Set the Java 8 profile (source compatibility level)
• Check if the sources compile and that you are able to
run ConfigureYourLambdaBuildOfJdk

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

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

30. Lambdas Hands-on-Lab:
Internal vs External Iteration
Java 7 (External)
for (Shape shape: myShapes) {
shape.setColor(RED);
}
Java 8 (Internal)
myShapes.forEach(shape ->
shape.setColor(RED));

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

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

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

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

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

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

37. Lambdas Hands-on-Lab:
Hints
Examples:
The basic syntax of a lambda is either
(parameters) -> expression
1. (int x, int y) -> x + y
or
2. (x, y) -> x - y
(parameters) -> { statements; }
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()");} }

38. Other New Features in JDK 8

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

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

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

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

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

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

45. 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 plugins to provide stronger type checking
• Sample annotations: @notnull, @readonly
• Enhancements to JSR 269 (Pluggable
Annotation Processing API)

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

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

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

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

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

51. Some books

52. JEPs and JDK 9 Development

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

54. Q&A

55. References
OpenJDK 8 early access builds
https://jdk8.java.net/
Oracle JDK 8 early access builds
http://www.oracle.com/technetwork/java/javase/d
ownloads/ea-jsp-142245.html
Eclipse with JDK 8 support
https://wiki.eclipse.org/JDT_Core/Java8

56. References
OpenJDK mercurial repositories
http://hg.openjdk.java.net/
OpenJDK 9 build instructions
http://hg.openjdk.java.net/jdk9/jdk9/rawfile/tip/README-builds.html
JSR 337: Java SE 8 (Early Draft Review Specification)
http://cr.openjdk.java.net/~mr/se/8/java-se-8edr-spec.html

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

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