Java 8 – New Features ”; Previous Next JAVA 8 is a major feature release of JAVA programming language development. Its initial version was released on 18 March 2014. With the Java 8 release, Java provided supports for functional programming, new JavaScript engine, new APIs for date time manipulation, new streaming API, etc. Following is the list of new features supported in Java 8: Lambda Expressions Lambda expression is one of the biggest feature introduced in Java. A lambda expression facilitates functional programming in Java. A lambda expression works on the principle of functional interface. A Functional interface is an interface with only one method to implement. A lambda expression provides an implementation of the functional interface method. Lambda expression simplifies functional programming a lot and makes code readable without any boilerplate code. A lambda expression can infer the type of parameter used and can return a value without a return keyword. In the case of the simple one-statement method, even curly braces can be eliminated. Example – Using Lambda Expressions Following example showcases the use of lambda expression. A lambda expression works best with a functional interface, an interface with single abstract method. We”ve defined one interface Calculator with single method operate, which can accept two parameters and return a value. In main method, we”ve implemented the Calculator interface using anonymous function first and then using a lambda expression. The operate() method is called to print the result in both cases and results are printed. package com.tutorialspoint; public class Tester { public static void main(String[] args) { // Interface implementation using anonymous class Calculator sum = new Calculator() { @Override public int operate(int a, int b) { return a + b; } }; int result = sum.operate(2,3); System.out.println(result); // Interface implementation using lambda expression Calculator sum1 = (a,b) -> a + b; result = sum1.operate(2,3); System.out.println(result); } interface Calculator { int operate(int a, int b); } } Let us compile and run the above program, this will produce the following result − 5 5 Method References Method reference is a short and concise way to call methods, static methods and even constructors without any lengthy syntax. Method references help to point to methods by their names even without specifying the arguments. Arguments are passed by the lambda expression. A method reference is described using “::” symbol. A static method can be referred using following syntax: <<class-name>>::methodName An instance method can be referred using following syntax: <<object-name>>::methodName We can invoke constructor using following syntax: <<class-name>>::new Example – Using Method References In this example, we”ve used a static method compare and an instance method compareTo to sort two arraylist of integers. We”ve used method references to represent both static and instance methods. package com.tutorialspoint; import java.util.Arrays; import java.util.List; public class Tester { public static void main(String args[]) { List<Integer> numbers = Arrays.asList(1,2,4,9,8,7,3); System.out.println(“Sorted using static method reference”); // Use static method compare numbers = numbers.stream().sorted(Integer::compare).toList(); System.out.println(numbers); numbers = Arrays.asList(1,2,4,9,8,7,3); System.out.println(“Sorted using instance method reference” ); // Use instance method compareTo numbers = numbers.stream().sorted(Integer::compareTo).toList(); System.out.println(numbers); } } Let us compile and run the above program, this will produce the following result − Sorted using static method reference [1, 2, 3, 4, 7, 8, 9] Sorted using instance method reference [1, 2, 3, 4, 7, 8, 9] Default Methods Before Java 8, an interface could have only abstract methods. With Java 8, lambda expression were introduced. Now for backward compatability, default method capability was added so that old interfaces can leverage lambda expression without modifying their implementations. For example, List or Collection interfaces do not have ”forEach” method declaration. Thus, adding such method will simply break the collection framework implementations. Java 8 introduces default method so that List/Collection interface can have a default implementation of forEach method, and the class implementing these interfaces need not implement the same. Syntax The following is the syntax of the default method in interface in Java − public interface vehicle { default void message() { System.out.println(“I am a vehicle!”); } } Example – Using Default Method In this example, we”ve created an interface with a default method. In an implementing class, this message is not implemented and is used to print a message. package com.tutorialspoint; interface vehicle { // default method must have an implementation default void message() { System.out.println(“I am a vehicle!”); } } // implementing class need not to implement the default method // of an interface. public class Tester implements vehicle { public static void main(String args[]) { Tester tester = new Tester(); // implementing class can access the default method as its own method tester.message(); } } Let us compile and run the above program, this will produce the following result − I am a vehicle! Stream API Stream API is a new abstract layer introduced in Java 8 to process data in a declarative way. A stream represents a sequence of elements. A stream provides a set of elements of specific type in a sequential manner. A stream gets/computes elements on demand. It never stores the elements. Stream supports aggregate operations like filter, map, limit, reduce, find, match, and so on and can do the iterations internally over the source elements provided, in contrast to Collections where explicit iteration is required. Syntax Following is the generic syntax to use a stream <<collection-instance>>.stream().<<non-terminal-operation()>>.<<non-terminal-operation()>>.<<terminal-operation()>> Example – Using Stream In this example, we”ve created a list of strings where few entries are empty. Now using stream API, we”re filtering the empty strings and counting them. package com.tutorialspoint; import java.util.Arrays; import java.util.List; public class Tester { public static void main(String args[]) { List<String> strings = Arrays.asList(“abc”, “”, “bc”, “efg”, “abcd”,””, “jkl”); // get stream from list using stream() method // then apply filter // lastly count the result of filter long count = strings.stream().filter(string->string.isEmpty()).count(); System.out.println(“Empty Strings: ” + count); } } Let us compile and run the above program, this will produce the following result − Empty Strings: 2 Optional Class Optional class feature was introduced in java 8 to handle Null