1. The Future of Java Development with Java 8/9
Jeffrey Poore
Senior Application Architect
Bank of America

2. About Me
Graduated from MIT in 1998, Bachelors in Computer Science and Engineering
Software Developer in the areas of Telephony, Finance, Health Care and Utilities
Most recently moved into a Senior Architect Role at Bank of America
Been developing in Java for over 10 years
Love Spring, Hibernate, JBoss, and IntelliJ

3. Overview Java 1.0 – Java SE/EE 7 – A Walk Down Memory Lane
Java 8 – Lambda Expressions, Method References, Stream APIs
Java 9 – Modular JDK, Jshell
Q/A

4. Java 1.0 – Java SE/EE 7 Java 1.0 (Oak) – January 23, 1996:
Classes, methods, basic java.lang libraries
Alpha and Beta JDKs
Abstract methods as in C++ (no abstract class)
Private access was actually package private
All exceptions unchecked
Java Applets
Hot Java

5. Java 1.0 – Java SE/EE 7 Java 1.1 – February 19, 1997: Inner classes
JavaBeans API
Java Database Connectivity (JDBC)
Java Remote Method Invocation (RMI)
Reflection (introspection only)
Just-in-Time Compiler (JIT) [on Windows, produced by Symantec]
Internationalization and Unicode

6. Java 1.0 – Java SE/EE 7
J2SE 1.2 (Playground, aka Java 2) – December 8, 1998:
strictfp keyword (portability of floating point calculations)
Swing Graphical UI
JIT in the Sun JVM
Java Plug-in for Web Browsers
Java IDL (Corba)
Collections framework

7. Java 1.0 – Java SE/EE 7 J2EE 1.2 – December 12, 1999: Java Servlet API
JavaServer Pages (JSP)
Enterprise JavaBeans API (EJB)
Java Naming and Directory Interface Specification (JNDI)
Java Message Service API (JMS)
Java Transaction API (JTA)

8. Java 1.0 – Java SE/EE 7 J2SE 1.3 (Kestrel) – May 8, 2000:
HotSpot JVM
JNDI included in core libraries
Java Platform Debugger Architecture (JPDA) – debugging framework
J2EE 1.3 – September 24, 2001:
Java API for XML Processing (JAXP)
JavaServer Pages Standard Tag Library (JSTL)
J2EE Connector Architecture – for connecting to legacy enterprise systems
Java Authentication and Authorization Service (JAAS)

9. Java 1.0 – Java SE/EE 7 J2SE 1.4 (Merlin) – February 6, 2002:
Java Community Process (JSR)
assert keyword
Regular Expressions (modeled after Perl)
IPv6 Support
Non-blocking I/O (NIO)
Logging API
Integrated security and cryptography extensions (JCE, JSSE, JAAS)
Java Web Start
Preferences API (java.util.prefs)

10. Java 1.0 – Java SE/EE 7 J2EE 1.4 – November 11, 2003:
Web Services for J2EE
Java API for XML-based RPC (JAX-RPC)
JavaServer Faces (JSF)
Java Authorization Service Provider Contract for Containers (JACC)
Java Management Extensions (JMX)
Enterprise Edition Management/Deployment APIs

11. Java 1.0 – Java SE/EE 7 J2SE 5.0 (Tiger) – September 30, 2004
Version number changed to “better reflect the level of maturity, stability and security of the J2SE”
Generics
Annotations
Autoboxing
Enumerations (enum keyword)
Varargs
Enhanced for
for (String s : List<String>) { }
Static Imports
Concurrency Utilities

12. Java 1.0 – Java SE/EE 7 E J B 3 J2EE 5 – May 11, 2006:
Java Architecture for XML Binding (JAXB)
SOAP with Attachments API (SAAJ)
Streaming API for XML (StAX)
EJB 3.0
Java Persistence API (JPA) E J B 3

13. Java 1.0 – Java SE/EE 7 Java SE 6 (Mustang) – December 11, 2006:
Mucked with the versioning again (sigh)
Scripting language support
Java API for XML Web Services (JAX-WS)
Java Compiler API – API to allow a Java program to compile code at runtime
New garbage collection algorithms
Java EE 6 – December 10, 2009:
Java API for RESTful Web Services (JAX-RS)
Java APIs for XML Messaging (JAXM)
JSP Expression Language (EL)

14. Java 1.0 – Java SE/EE 7 Java SE 7 (Dolphin) – July 7, 2011:
Oracle buys Sun (January 27, 2010)
JVM support for dynamic languages
Strings in switch statement
Automatic resource management in try statement
try (InputStream is = openStream()) { … }
Improved type inference for Generics
List<String> lst = new ArrayList<>();
Binary integer literals and underscores in numeric literals
0b1111_0101_0011, 1_204_304.44
Multiple Exception Catch
catch (IOException | NullPointerException e) { … }
Java EE 7 – June 12, 2013:
Java API for WebSocket
Java API for JSON Processing

15. Java SE 8 – March 18, 2014 No cute nickname, sorry Features:
Lambda Expressions
Method References
Stream APIs
Annotation on Java Types / Repeating Annotations
Unsigned Integer Arithmetic
New Date/Time API
Removed Perm Gen
Java EE 8 still in JSR Process

16. Lambda Expressions
A Lambda Expression is similar to a function pointer in C
() -> System.out.println("Hello World!") // no parameters
a -> a // identity function
(a, b) -> a + b // multiple parameters
(long id, String name) { … } // explicit typing
(a, b) -> { return a + b; } // with a code block
(id, defaultPrice) -> { // multiple lines
Optional<Product> product = productList.stream().filter(p -> p.getId() == id).findFirst();
return product.map(p -> p.getPrice()).orElse(defaultPrice); }

17. Lambda Expressions
Lambda Expressions are used where functional interfaces are expected
interfaces that only contain one abstract method
the interfaces can have default or static methods
a lambda expression is a valid return value

18. Lambda Expressions
public class Calculator { interface Operation { int execute(int a, int b); default Operation swap() { return (a, b) -> execute(b, a); } } public static int apply(int a, int b, Operation op) { return op.execute(a, b); } ... }

19. Lambda Expressions
public static void main(String … args) { Operation addition = (a, b) -> a + b; Operation subtraction = (a, b) -> a – b; println(" = " + Calculator.apply(40, 2, addition); // " = 42" println("20 – 10 = " + Calculator.apply(20, 10, subtraction); // "20 – 10 = 10" println("10 – 20 = " + Calculator.apply(20, 10, subtraction.swap()); // "10 – 20 = -10" }

20. Method References A method reference is similar to a lambda function
Instead of providing an implementation, you provide a reference to an existing one
The method referenced doesn't have to be a part of a class that implements the given interface
only the signature of the method needs to match

21. Method References
class Person { public static int compareByAge(Person a, Person b) { return a.dateOfBirth.compareTo(b.dateOfBirth); } class PersonAgeComparator implements Comparator<Person> { public int compare(Person a, Person b) { return Person.compareByAge(a, b); } } public static void main(String … args) { Person[] people = getPeople(); Arrays.sort(people, new PersonAgeComparator()); }

22. Method References There has to be a better way, right? There is:
sort has this signature:
static <T> void sort(T[] a, Comparator<? super T> c);
Comparator is a functional interface, therefore a Lambda expression could be used:
Arrays.sort(people, (a, b) -> return Person.compareByAge(a, b));
But why create a lambda expression only to call to a method with the same signature?
This is what a method reference is for!

23. Method References
class Person { public static int compareByAge(Person a, Person b) { return a.dateOfBirth.compareTo(b.dateOfBirth); } public static void main(String … args) { Person[] people = getPeople(); Arrays.sort(people, Person::compareByAge); }

24. Stream API
Stream API is an optimized way of working with Collections (List, Map, etc)
Uses Lambda Expressions and Method References
Brings Java in line with other languages that allow for quick collection processing (Perl, Python, Ruby)

25. Without Stream API
List<String> strList = getStrings(); List<String> result = new ArrayList<String>(); for (String s : strList) { if (s.startsWith("abc")) { result.add(s); } } for (int idx = 0; idx < result.size(); idx++) { result.set(idx, result.get(idx).toUpperCase()); } result.sort(new Comparator<String>() { … return StringUtil.reverseSort(a, b); … } for (String s : result) { System.out.println(s); }

26. With Stream API List<String> strList = getStrings();
strList.stream() // opens the stream
.filter(s -> s.startsWith("abc")) // filter the list
.map(s -> s.toUpperCase()) // transform each item
.parallel() // convert to parallel stream
.sorted(StringUtil::reverseSort) // sort with existing method
.forEach(s -> System.out.println(s)) // print each item

27. Java SE 9 – TBD – Early 2017 Codename: Jigsaw Features:
Built-in Module System
Jshell – interactive Java!
Private Interface Methods
Improved Process API
Stackwalker
Centralized Logging API
Publisher/Subscriber Streams
Collection Factory Methods
HTTP/2 Support

28. Module System
Some of us are familiar with the package-info.java file, which is for package level javadocs
Java 9 introduces a module-info.java file that contains module info:
module com.funcompany {
requires java.logging;
requires java.xml;
exports com.funcompany.public.api;
exports com.funcompany.public.domain; }

29. Module System
Allows modules to declare dependencies (including potentially versions, still being refined)
Allows modules to declare exported classes (i.e., code using the module will not be allowed to load private classes, even for reflection)
Module relationships are documented with Javadoc
Also allows for defining "services" for explicitly naming classes that provide service-like functionality

30. Jshell Interactive Java Shell Define classes, methods, variables, etc
List what is in scope (what has been defined)
Call methods, assign values to variables, import types
Basically a playground for Java
Demo

31. Q & A