Page 1 of 10

Java 8 - New Features

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.

Open Compiler

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) {
 Page 2 of 10

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:

 Page 3 of 10

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

Open Compiler

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]
 Page 4 of 10

Learn Java in-depth with real-world projects through our Java certification course.
Enroll and become a certified expert to boost your career.

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.

Open Compiler

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

 Page 5 of 10

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

Open Compiler
 Page 6 of 10

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 Pointer Exception scenarios
programmatically, to make programs more concise, less error prone. A Null Pointer
Exception occurs whenever a null object reference is used to get value from it or to
invoke its method. As program size increases, it is very tedious to handle all cases where
Null Pointer Exception can happens.

Optional Class instance provides a wrapper over the object with many utility methods like
to get the alternate value if underlying value is null, to check if object reference is null
and so.

Example - Using Optional Class

In this example, we've created two Optional class instance using oofNullable() method
which allows to pass underlying object as null and then retrieved the value using orElse()
method, which returns a default value if underlying object is null.
 Page 7 of 10

Open Compiler

package com.tutorialspoint;

import java.util.Optional;

public class Tester {

public static void main(String args[]) {
// case 1: Optional is having null as underlying value
Optional<Integer> valueOptional = Optional.ofNullable(null);

// case 2: Optional is having not null as underlying value

Optional<Integer> valueOptional1 =
Optional.ofNullable(Integer.valueOf(10));

// orElse will return -1 being default value

Integer value = valueOptional.orElse(Integer.valueOf(-1));

System.out.println(value);

// orElse will return the underlying value

Integer value1 = valueOptional1.orElse(Integer.valueOf(-1));

System.out.println(value1);
}
}

Let us compile and run the above program, this will produce the following result −

-1
10

New Date Time API

Java 8 introduced a new Date Time API which is thread safe, zone ready and multiple
direct methods to handle date operations. Earlier date-time API was not thread safe and
in concurrency issues could pop up while working with dates. New date time APIs are
using immutable constructs and no setter method thus making API more secure. The
new API is designed considering zone, domain specific requirements.

Java 8 introduces a new date-time API under the package java.time. Following are some
of the important classes introduced in java.time package.
 Page 8 of 10

Local − Simplified date-time API with no complexity of timezone handling.

Zoned − Specialized date-time API to deal with various timezones.

Example - Using Date Time APIs

In this example, we've created two Optional class instance using oofNullable() method
which allows to pass underlying object as null and then retrieved the value using orElse()
method, which returns a default value if underlying object is null.

Open Compiler

package com.tutorialspoint;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.ZonedDateTime;

public class Tester {

public static void main(String args[]) {
// Get the current date and time
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("Current DateTime: " + currentTime);

LocalDate date1 = currentTime.toLocalDate();

System.out.println("date1: " + date1);

Month month = currentTime.getMonth();

int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();

System.out.println("Month: " + month +", day: " + day +",

seconds: " + seconds);

ZonedDateTime date2 = ZonedDateTime.parse("2007-12-

03T10:15:30+05:30[Asia/Karachi]");
System.out.println("date2: " + date2);
}
}
 Page 9 of 10

Let us compile and run the above program, this will produce the following result −

Current DateTime: 2024-03-07T10:29:15.650806

date1: 2024-03-07
Month: MARCH, day: 7, seconds: 15
date2: 2007-12-03T09:45:30+05:00[Asia/Karachi]

Nashorn JavaScript Engine

Nashorn, a very powerful and efficient Javascript engine, is introduced as a replacement
of existing javascript engine, Rhino. Nashorn engine is touted to be 2 to 10 times faster
as it can directly compile the JavaScript Code to bytecode. Nashorn engine allows to run
execute JavaScript code in Java file and we can even execute java code within a
JavaScript code snippet. With Nashorn engine, a command line tool jjs was introduced to
run the javascript in command line tools.

Execute JavaScript Directly in Command Prompt

Open the console and type jjs and press enter button. jjs tool will open an interactive
session. Once jjs session is open, we can execute a javascript code. Once done, type
quit() and press enter button to exit the jjs interactive session and to return back to the
command prompt.

Example

C:\JAVA>jjs
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>
C:\JAVA>

Example - Using Javascript code within Java Code

Java has a ScriptEngineManager class since Java 6, which is used in this example to load
the javascript engine as ScriptEngine instance. Once engine is loaded in the java code,
we can call eval() method to evaluate a JavaScript code in Java. We can even use Java
variable(s) in javascript code snippet.

package com.tutorialspoint;
 Page 10 of 10

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Tester {

public static void main(String args[]) {

// create the script engine manager
ScriptEngineManager scriptEngineManager = new
ScriptEngineManager();
// load the Nashorn javascript engine
ScriptEngine nashorn =
scriptEngineManager.getEngineByName("nashorn");

String message = "This is a message";

String expression = "10 + 2";
Integer result = null;

try {
// call the javascript function, pass a java variable
nashorn.eval("print('" + message + "')");
// call the javascript function and get the result back in
java
result = (Integer) nashorn.eval(expression);

} catch(ScriptException e) {
System.out.println("Error executing script: "+
e.getMessage());
}
System.out.println(result.toString());
}
}

Let us compile and run the above program, this will produce the following result −

This is a message
12

Nashorn engine was deprecated in java 11 and removed in java 15 and is replaced by
GraalVM javascript engine.