Colloquium Report

Faizan, Mohammad | MCA | May 4, 2015

JAVA 8

IntroductionJAVA 8 (JDK 1.8) is a major release of JAVA programming language development. Its initial version was released on 18 March 2014. With the Java 8 release, Java provided support for functional programming, new JavaScript engine, new APIs for date time manipulation, new streaming API, etc.

New FeaturesThere are dozens of features added to Java 8, the most significant ones are mentioned below −

Lambda expression − Adds functional processing capability to Java.

Method references − Referencing functions by their names instead of invoking them directly. Using functions as parameter.

Default method − Interface to have default method implementation.

New tools − New compiler tools and utilities are added.

Stream API − New stream API to facilitate pipeline processing.

Date Time API − Improved date time API.

Optional Class − Emphasis on best practices to handle null values properly.

The Biggest thing in java 8 is functional programming that means with java we can not only object composition but we can also do functional composition.

We can achieve functional programming with java 8 with Lambda expression.

PAGE 1

Evolution • The lambda calculus was introduced in the 1930s by

Alonzo Church as a mathematical system for defining computable functions.

• The lambda calculus is equivalent in definitional power to that of Turing machines.

• The lambda calculus serves as the computational model underlying functional programming languages such as Lisp, Haskell, and Ocaml

• Features from the lambda calculus such as lambda expressions have been incorporated into many widely used programming languages like C++ and now very recently Java 8.

What is Lambda CalculusThe central concept in the lambda calculus is an expression generated by the following grammar which can denote a function definition, function application, variable, or parenthesized expression:

expr → λ var . expr | expr expr | var | (expr)

We can think of a lambda-calculus expression as a program which when evaluated by beta-reductions returns a result consisting of another lambda-calculus expression.

Functional Programming A style of programming that treats computation as the evaluation of mathematical functions

Eliminates side effects

PAGE 2

Treats data as being immutable Expressions have referential transparency Functions can take functions as arguments and return functions

as results Prefers recursion over explicit for-loops

Methods with Case study

1. Java 8 is the biggest change to Java since the inception of the language

2. Lambdas are the most important new addition3. Java is playing catch-up: most major programming languages

already have support for lambda expressions4. A big challenge was to introduce lambdas without requiring

recompilation of existing binaries

Lambda and Functional Interface

Lambdas (also known as closures) are the biggest and most awaited language change in the whole Java 8 release. They allow us to treat functionality as a method argument (passing functions around), or treat a code as data: the concepts every functional developer is very familiar with. Many languages on JVM platform (Groovy, Scala, …) have had lambdas since day one, but Java developers had no choice but hammer the lambdas with boilerplate anonymous classes.

Lambdas design discussions have taken a lot of time and community efforts. But finally, the trade-offs have been found, leading to new concise and compact language constructs. In its simplest form, a lambda could be represented as a comma-separated list of parameters, the –> symbol and the body. For example:

PAGE 3

1 Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );

Default and Static Method

Java 8 extends interface declarations with two new concepts: default and static methods. Default methods make interfaces somewhat similar to traits but serve a bit different goal. They allow adding new methods to existing interfaces without breaking the binary compatibility with the code written for older versions of those interfaces.

The difference between default methods and abstract methods is that abstract methods are required to be implemented. But default methods are not. Instead, each interface must provide so called default implementation and all the implementers will inherit it by default (with a possibility to override this default implementation if needed). Let us take a look on example below.

private interface Defaulable {

// Interfaces now allow default methods, the implementer may or

// may not implement (override) them.

default String notRequired () {

return "Default implementation";

}

}

PAGE 4

private static class DefaultableImpl implements Defaulable {

}

private static class OverridableImpl implements Defaulable {

@Override

public String notRequired() {

return "Overridden implementation";

}

}

Method References

Method references provide the useful syntax to refer directly to exiting methods or constructors of Java classes or objects (instances). With conjunction of Lambdas expressions, method references make the language constructs look compact and concise, leaving off boilerplate.

Below, considering the class Car as an example of different method definitions, let us distinguish four supported types of method references.

public class FunctionalStyle { public static void main (String [] args) {

List<Integer> values = Arrays.asList(1, 2, 3, 4, 5, 6); System.out.println(" With for iterator"); int total = 0;

for (int e: values) { total += e*2; } System.out.println(total);

PAGE 5

values. stream () . map(e->e*2) . reduce (0, (c,e)->c+e).forEach(System.out::print);

}}

Repeating annotationsSince Java 5 introduced the annotations support, this feature

became very popular and is very widely used. However, one of the limitations of annotation usage was the fact that the same annotation cannot be declared more than once at the same location. Java 8 breaks this rule and introduced the repeating annotations. It allows the same annotation to be repeated several times in place it is declared.

@Color(name = "Red")@Color(name = "Blue")@Color(name = "Black")

public class Shirt { public static void main(String[] args) { Color[] colors = Shirt.class.getAnnotationsByType(Color.class); for (Color cl : colors ) System.out.println(cl.name()); }}

PAGE 6

Better Type InferenceJava 8 compiler has improved a lot on type inference. In many

cases the explicit type parameters could be inferred by compiler keeping the code cleaner. Let us take a look on one of the examples.

public class Boundary {

public void hello(String name, int age) { } public static void main(String[] args) { Method[] methods = Boundary.class.getMethods(); for (Method method : methods) { System.out.print(method.getName() + "(");

Parameter[] parameters = method.getParameters(); for (Parameter parameter : parameters) { System.out.print(parameter.getType().getName() + " " + parameter.getName() + " "); } System.out.println(")"); } }}

 Optional ClassThe famous NullPointerException is by far the most

popular cause of Java application failures. Long time ago the great Google project introduced the Optional as a solution to NullPointerExceptions, discouraging codebase pollution with null checks and encouraging developers to write cleaner code. Inspired by Google Guava, the Optional is now a part of Java 8 library.

Optional is just a container: it can hold a value of some type T or just be null. It provides a lot of useful methods so the explicit null checks have no excuse anymore. Please refer to official Java 8 documentation for more details.

PAGE 7

We are going to take a look on two small examples of Optional usages: with the null able value and with the value which does not allow nulls.

 StreamsThe newly added Stream API (java.util.stream) introduces real-

world functional-style programming into the Java. This is by far the most comprehensive addition to Java library intended to make Java developers significantly more productive by allowing them to write effective, clean, and concise code.Stream API makes collections processing greatly simplified (but it is not limited to Java collections only as we will see later). Let us take start off with simple class called Task.

public class ParallelStreams { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,10);

System.out.println("With Stream");

numbers.stream() .forEach(e -> System.out.print(e + " ")); System.out.println(" \nWith parallelStream : 1");

numbers.parallelStream() .forEach(e -> System.out.print(e + " "));

System.out.println("\nWith parallelStream : 2"); numbers.parallelStream() .forEach(e -> System.out.print(e + " "));

PAGE 8

System.out.println("\nWith parallelStream : 3"); numbers.parallelStream() .forEach(e -> System.out.print(e + " "));

}}

 Base64Finally, the support of Base64 encoding has made its way into Java standard library with Java 8 release. It is very easy to use as following example shows off.

The particular set of 64 characters chosen to represent the 64 place-values for the base varies between implementations. The general strategy is to choose 64 characters that are both members of a subset common to most encodings, and also printable. This combination leaves the data unlikely to be modified in transit through information systems, such as email, that were traditionally not 8-bit clean

public class Base64s {

public static void main (String [] args) { String text = "Base 64 Finally In Java";

PAGE 9

String encode = Base64.getEncoder() .encodeToString(text.getBytes(StandardCharsets.US_ASCII)); System.out.println(encode); String decode = new String( Base64.getDecoder().decode(encode) , StandardCharsets.US_ASCII ); System.out.println(decode); }

}

 New Features in Java runtime (JVM)

The PermGen space is gone and has been replaced with Metaspace  . The JVM options -XX:PermSize and –XX:MaxPermSize have been replaced by -XX:MetaSpaceSize and -XX:MaxMetaspaceSize respectively.

ConclusionThe future is here: Java 8 moves this great platform forward by

delivering the features to make developers much more productive. It is too early to move the production systems to Java 8 but in the next couples of months its adoption should slowly start growing. Nevertheless, the time is right to start preparing your code bases to

PAGE 10

be compatible with Java 8 and to be ready to turn the switch once Java 8 proves to be safe and stable enough.As a confirmation of community Java 8 acceptance, recently Pivotal Released Spring Framework 4.0.3 with production-ready Java 8 support.

ResourcesSome additional resources which discuss in depth different aspects

of Java 8 features: What’s New in JDK 8: http://www.oracle.com/technetwork/java/javase/8-

whats-new-2157071.html The Java Tutorials: http://docs.oracle.com/javase/tutorial/ WildFly 8, JDK 8, NetBeans 8, Java EE

7: http://blog.arungupta.me/2014/03/wildfly8-jdk8-netbeans8-javaee7-excellent-combo-enterprise-java/

Java 8 Tutorial: http://winterbe.com/posts/2014/03/16/java-8-tutorial/ JDK 8 Command-line Static Dependency

Checker: http://marxsoftware.blogspot.ca/2014/03/jdeps.html The Illuminating Javadoc of JDK

8: http://marxsoftware.blogspot.ca/2014/03/illuminating-javadoc-of-jdk-8.html

The Dark Side of Java 8: http://blog.jooq.org/2014/04/04/java-8-friday-the-dark-side-of-java-8/

Installing Java™ 8 Support in Eclipse Kepler SR2: http://www.eclipse.org/downloads/java8/

Java 8: http://www.baeldung.com/java8 Oracle Natron. A Next-Generation JavaScript Engine for the

JVM: http://www.oracle.com/technetwork/articles/java/jf14-nashorn-2126515.html

PAGE 11