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

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

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

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

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

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

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)

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)

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)

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

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

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

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)

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

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

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

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

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

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

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

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()); }

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!

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

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)

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

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

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

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; }

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

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

Q & A