Java 8 Features Interview Questions

Java 8 Features Interview Questions

1. What New Features Were Added in Java 8?

Java 8 ships with several new features but the most significant are the following:

Lambda Expressions − a new language feature allowing treating actions as objects
Method References − enable defining Lambda Expressions by referring to methods directly using their names
Optional − special wrapper class used for expressing optionality
Stream API − a special iterator class that allows processing collections of objects in a functional manner
Functional Interface – an interface with maximum one abstract method, implementation can be provided using a Lambda Expression
Default methods − give us the ability to add full implementations in interfaces besides abstract methods
Nashorn, JavaScript Engine − Java-based engine for executing and evaluating JavaScript code

2. How Streams differ from collections?

No storage. A stream is not a data structure that stores elements; instead, it conveys elements from a source such as a data structure, an array, a generator function, or an I/O channel, through a pipeline of computational operations.
Functional in nature. An operation on a stream produces a result, but does not modify its source. For example, filtering a Stream obtained from a collection produces a new Stream without the filtered elements, rather than removing elements from the source collection.
Laziness-seeking. Many stream operations, such as filtering, mapping, or duplicate removal, can be implemented lazily, exposing opportunities for optimization. For example, “find the first  String with three consecutive vowels” need not examine all the input strings. Stream operations are divided into intermediate (Stream-producing) operations and terminal (value- or side-effect-producing) operations. Intermediate operations are always lazy.
Possibly unbounded. While collections have a finite size, streams need not. Short-circuiting operations such as limit(n) or findFirst() can allow computations on infinite streams to complete in finite time.
Consumable. The elements of a stream are only visited once during the life of a stream. Like an Iterator, a new stream must be generated to revisit the same elements of the source.
In contrast, a Collection is a container of objects (elements). You can’t get (retrieve) an object from a collection unless the object was previously added to the collection.

3. What is the use of Functional Interface in Java 8?When to use Functional Interface in Java 8?

Reference – PART 1 : FUNCTIONAL INTERFACE AND DEFAULT METHODS IN JAVA 8
An interface having only single abstract method is called as functional interface. Functional interface can have multiple default or static methods.
We can create a functional interface as below :

package com.onlyfullstack.lambdaAndFunctional;

public interface IConnection {

 public void connect();
 
 default void print() {
  System.out.println("in default method");
 }
 
 static void description() {
  System.out.println("in static method");
 }
}

Functional interface can have only one abstract method(method without body) and can have many default and static methods. As of now we don’t have any restriction to add more abstract methods in above interface but it will break the functional interface rule.

6. What is Lambda Expression in Java 8?

Lambda expression facilitates the functional programming and simplifies the development. Lambda expression is a shorter way of writing an implementation of a single abstract method interface. Lambda expressions are used to create anonymous functions.

Syntax:
(parameters) -> expression
or
(parameters) -> { statements; }

Java 8 provide support for lambda expressions only with functional interfaces.

Lets see how to use lambda to remove the boilerplate code. We will implement the Runnable interface with anonymous class and with lambda expression.

private static void simpleConceptWithRunnable() {
 Runnable runnable = new Runnable() { // boilerplate code which needs to be written everytime
  @Override
  public void run() {
   System.out.println("Inside annonymos inner class");
  }
 };
 
 Runnable runnable2 = () -> { // Lambda expression
         System.out.println("Inside lambda expression");
    };
 
 Thread thread = new Thread(runnable);
 thread.start();
 
 thread = new Thread(runnable2);
 thread.start();
}

We wrote a boilerplate code of creating an anonymous class and override the run method. Lambda takes care of this things and gives us a simple syntax to create a anonymous class. Lambdas are more than anonymous classes.
Reference – PART 2 – LAMBDA EXPRESSION IN JAVA 8

private static void staticReference_WithMethodRef() {
 Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9);
 stream.filter(i -> i%2==0 )
  .forEach(MethodReference::printMe);
}

private static void instanceReferenceWithClass_WithMethodRef() {

 List<Student> students = JavaInputFixture.createList();
 
 Set<String> names = students.stream()
   .map(Student::getName) // this will convert the Student Stream into String Stream by 
           // applying the getName()
   .collect(Collectors.toSet());
 
 System.out.printf("Names of all students %sn", names);
}

private static void instanceReference_WithMethodRef() {
 Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9);
 stream.filter(i -> i%2==0 )
  .forEach(System.out::println);
}

Reference – PART 3 – METHOD REFERENCE IN JAVA 8

private static List<Student> createList() {

   Student student1 = new Student("Saurabh", "Pune", 26);
   Student student2 = new Student("Robert", "Pune", 25);
   Student student3 = new Student("John", "Mumbai", 21);
   Student student4 = new Student("Roman", "Pune", 18);
   Student student5 = new Student("Randy", "Mumbai", 17);
   
   return Arrays.asList(new Student[] {student1, student2, student3, student4, student5});
}

private static void filter(List<Student> students) {
   System.out.println("Executing filter() :");
   // Find the student whose name is Saurabh and return null if not found
   System.out.println("*** Students whos name is Saurabh *** ");
   Student stud = students.stream()
         .filter(student -> SAURABH.equals(student.getName()))
         .findAny()
         .orElse(null); // it will return null if filter does find any object matching the criteria 
   
   System.out.println(stud);
   System.out.println("Ending the execution of filter()");
}

int age = students.stream()
    .filter(student -> SAURABH.equals(student.getName()))
    .map(Student::getAge)
    .findAny()
    .orElse(0);
System.out.printf("*** Age of %s is %dn",SAURABH, age);

Set<String> courses = students.stream()
         .map(Student::getCourses)
         .collect(Collectors.toSet());

Here we will get a compilation error as below
Type mismatch: cannot convert from Set<String[]> to Set<String>
To resolve this issue we use flatMap()

flatMap()
It returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMap will transform the stream of stream into simple stream. In below example we are using the flatMap to convert the Array of Stream into the String stream.

Set<String> courses = students.stream()
         .map(Student::getCourses)
         .flatMap(Arrays::stream)
         .collect(Collectors.toSet());

int [] arr = {1,2,3,4,5,6,7,8,9};
  
Integer findFirst = Arrays.stream(arr).filter(i -> (i%2) == 0)
  .findFirst()
  .orElse(-1);

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

Integer findAny = Arrays.stream(arr).filter(i -> (i%2) == 0)
  .findAny()
  .orElse(-1);

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