Introduction To Java 8

Introduction

Java, the most widespread programming language for software development, has been brought to a new phase after introducing some new features. In this article, I will be explaining about new features in Java 8. If you are thinking that it's just yet another update of Java -- then “NO” it is much different from older versions of Java 1.0 to 1.7.

We got three important new features which are listed as,

Functional Programming
Lambda Expressions
Stream API

Including these three features, Java 8 includes many more features which are also listed:

Default and static Methods inside Interface.
forEach() method in interface(iterable)
Optional Class
Method References
Date Time API
Nashorn JavaScript Engine
Functional Interface
Collection API Improvements
String Joiner

Explanation

For years, we have been implementing our code (programming logic) with objects, but here the main thing is behavior of the object; i.e functionality of the object. For this we have two techniques,

Imperative Programming : specifies what to do and how to do it.
Declarative Programming : specifies what to do.

Here are some brief descriptions of all the features listed above, detailed explanations will be shared for each feature shortly with you.

Functional Programming: As explained earlier, for years we have been using objects in our code irrespective of the language used for software development, here Java has come up with a feature to use functional programming; i.e instead of focusing on objects here we focus on functions .
Functional Interface: It is an interface that contains only one abstract method. It can have only one functionality to exhibit. It can be easily recognized by the @FunctionalInterface annotation.

Here, lambda expressions can be used to represent instances of functional Interface.

EmployeeController.java

public class EmployeeController {
public static void main(String[] args) {
List < Employee1 > list = Arrays.asList(new Employee1(1, "ABC1", "UP1", 10000), new Employee1(2, "ABC2", "UP2", 2000), new Employee1(3, "ABC3", "UP3", 30000), new Employee1(4, "ABC4", "UP4", 40000), new Employee1(5, "ABC5", "UP5", 50000));
Employee1[] emp = (Employee1[]) list.toArray();
Predicate < Employee1 > predicate = e - > e.getSalary() > 10000;
Arrays.stream(emp).filter(predicate).forEach(System.out::println);
}
}

Employee.java

public class Employee {
private int id;
private String name;
private String location;
private double salary;
public Employee1(int id, String name, String location, double salary) {
super();
this.id = id;
this.name = name;
this.location = location;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Employee1 [id=" + id + ", name=" + name + ", location=" + location + ", salary=" + salary + "]";
}
}

The code will produce output as,

Employee[id = 2, name = ABC2, location = UP2, salary = 20000.0]
Employee[id = 3, name = ABC3, location = UP3, salary = 30000.0]
Employee[id = 4, name = ABC4, location = UP4, salary = 40000.0]
Employee[id = 5, name = ABC5, location = UP5, salary = 50000.0]

Lambda Expressions

It means a block of code that you can pass around and we can execute it later, it uses a new -> operator, can be made of zero, one or multiple lines. It is used to remove the boilerplate code and focus on the main thing.

Syntax to use lambda expressions : lambda operator -> body

Example

LambdaDemo.java

interface A {
void show();
}
public class LambdaDemo {
public static void main(String[] args) {
A obj; //reference to interface
//Lambda Expression without Parameter
obj = () - > {
System.out.println("Hello");
};
obj.show();
//Lambda Expression with Parameter
obj = (name) - > {
System.out.println("Hello " + name);
};
obj.show("Aman");
}
}

Java Stream API

A Stream is a sequence of elements from the source (collections) that supports parallel and sequential aggregate operations. A stream pipeline consists of source, followed by zero or more intermediate operations and a terminal operation.

Source - Filter - Collect
Source - Filter - Map - Collect

Example

StreamAPIDemo.java

public class StreamAPIDemo {
public static void main(String[] args) {
List < Integer > list = new ArrayList < > ();
list.add(3);
list.add(8);
list.add(9);
List < Integer > streamlist = list.stream() //source
.filter(x - > x % 2 == 0) //intermediate operation
.collect(Collectors.toList()); //terminate operation
System.out.println("Original List : " + list);
System.out.println("Filtered List : " + streamlist);
}
}

This code will provide output as,

Original List : [3, 8, 9]

Filtered List : [8]

Default and static Methods inside Interface

In earlier versions of Java, we can only declare functions inside an Interface but with the introduction of Java 8 era, we can even define methods inside an Interface and this can be achieved by using two keywords of Java,

Default and
Static

Default Methods in Interfaces

Before Java 8, Interfaces can only have abstract methods and final variables, to overcome this Java 8 introduced default methods which allows the interface to have methods with implementation.

Example

InterfaceDefaultMethod.java

interface DefaultMethod {
default void B() {
System.out.println("method B");
}
}
public class InterfaceDefaultMethod implements DefaultMethod {
public static void main(String[] args) {
DefaultMethod dm = new InterfaceDefaultMethod();
//object of class through Interface
dm.B();
}
}

This will produce an output as: method B

Static Methods in Interfaces

Static methods contain complete definition of the function, since the definition is complete and methods are static, they cannot be overridden.

InterfaceStaticMethod.java

interface StaticMethod {
static void B() {
System.out.println("method B");
}
}
public class InterfaceStaticMethod implements StaticMethod {
public static void main(String[] args) {
//access static method of Interface StaticMethod with its name
StaticMethod.B();
}
}

This will produce an output as: method B

forEach() method in interface(iterable)

forEach() method was introduced in Java 8 to iterate collection of elements. This method is useful when we want to iterate over the collection only. We can pass lambda expressions as an argument. We can even use Method Reference in this as an argument.

Signature of forEach() : default void forEach(Consumer<super T> action)

Where, Consumer<super T> is an interface added in Java 8 and is a type of functional Interface where it has only one abstract method with generic parameters of any type.

Example

ExampleForEachDemo.java

public class ExampleForEachDemo {
public static void main(String[] args) {
List < String > list = new ArrayList < > ();
list.add("One");
list.add("Two");
list.add("Three");
list.forEach(i - > System.out.println(i)); //Internal ForEach method
}
}

This code will provide output as,

One
Two
Three

Optional Class

Is Introduced in Java 8, and provides an easier way to avoid NullPointerException. This class has a basic feature to avoid program termination with NullPointerException if it occurs, to overcome this optional class comes into the picture.

By using optional instances we can specify alternate values to return or alternate code to run.

Different ways to use Optional Class,

Get the value.
Get if object is not null, else throw Exception
Get if object is not null, else return default
Consume the data

Example

OptionalClassDemo.java

public class OptionalClassDemo {
static String address = "Uttar Pradesh";
public static void main(String[] args) {
Optional < String > n = Optional.ofNullable(address);
if (n.isPresent()) System.out.print(n.get());
System.out.print("India");
}
}

This code will provide output as - Uttar Pradesh

Date Time API

The Java.time package contains Java 8 Date and Time classes. The classes represent principle date-time concepts, including instances, duration, date, time, time-zones and periods. All these classes are immutable and thread safe.

Some important classes included in Date Time API’s are,

java.time.LocalTime
java.time.LocalDate
java.time.LocalDateTime
java.time.Clock

Example

DateTimeAPIDemo.java

public class DateTimeAPIDemo {
public static void main(String[] args) {
LocalDate d = LocalDate.now();
System.out.println(d); //today's date
System.out.println(d.plusDays(10)); //date after 10 days
}
}

This code output as,

2020-07-14
2020-07-24

Nashorn JavaScript Engine

Nashorn JavaScript Engine was introduced in Java 8 and is used to interpret Javascript code in Java applications or from the command line. It is an implementation of ECMAScript edition 5.1.

Example

C:\Users\Dell>jjs
jjs> print("Hello World")
Hello World
jjs> a = 10
10
jjs> b = 20
20
jjs> a + b
30
jjs> quit()

What have we learned ?

After reading this article, users have a brief idea what Java 8 includes and can implement it in their codes. For a more detailed explanation on any feature of Java 8 check my other articles.

Note
While trying to work with any feature of java 8 remember to use JDK 1.8 or higher else these concepts and code will not work.

Summary

Coming to the end of the post let us have a quick recap of what we have learned so far,

Introduction with Java 8
Features of Java 8 and their implementation.
Lambda Expressions
Stream API
Functional Interface
Functional Programming and more.

8 Comments

Join the conversation! Your thoughts help the community grow.

Roshan Rathod6y ago
good one ..keep it up
- Aman Gupta6y ago
  Thanks for appreciation.
Priya Gupta6y ago
Nice content
- Aman Gupta6y ago
  Thanks for appreciation.
ankurr joshi6y ago
Superb breifing.
- Aman Gupta6y ago
  Thanks for appreciation
Pranshu Singhal6y ago
Thanks, now I am able to understand these things.
- Aman Gupta6y ago
  Thanks for appreciation