Java interview questions on streams

Posted by: Instanceofjava Posted date: February 02, 2025 / comment : 0 Java 8

Java interview questions on streams

Core Concepts

What is a Stream?
A sequence of elements that supports sequential or parallel operations. Streams do not store data; they operate on a source (e.g., collection) and support functional-style operations such as filter, map, and reduce.
Stream vs. Collection
- Collections store data, while streams process it on demand.
- Streams are lazy, meaning operations execute only when a terminal operation is invoked.
Intermediate vs. Terminal Operations
- Intermediate operations: filter, map, sorted (return a new stream, lazy).
- Terminal operations: collect, forEach, reduce (produce a result or side effect, eager).

Common Operations

Filter vs. Map
- filter(Predicate): Selects elements matching a condition.
- map(Function): Transforms elements into another shape, such as extracting a field.
Reduce
Combines elements into a single result, such as the sum of numbers:
```
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
```

FlatMap
Flattens nested collections (e.g., List<List> to List):

List<Integer> flatList = nestedList.stream().flatMap(List::stream).toList();

Advanced Concepts

Parallel Streams
- Allow processing to occur in multiple threads using parallelStream().
- Thread safety: Ensure the lambda expression is stateless or non-interfering.
Stateful vs. Stateless Operations
- Stateless: filter, map (do not depend on other elements).
- Stateful: distinct, sorted (must keep everything in memory).
Short-Circuiting Operations
These operations end processing early, such as findFirst, limit, and anyMatch.

Collectors

Collectors.toList
Collects the values of a stream into a list:

List<String> names = people.stream().map(Person::getName).toList();

GroupingBy
Groups elements by a classifier, such as grouping people by age:

Map<Integer, List<Person>> peopleByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge));

PartitioningBy
Splits elements into two groups (true/false) based on a predicate:

Map<Boolean, List<Person>> partitioned = people.stream()
    .collect(Collectors.partitioningBy(p -> p.getAge() >= 18));

Coding Problems

Find distinct elements in a list:

List<Integer> distinct = numbers.stream().distinct().toList();

Sum all even numbers:

int sum = numbers.stream().filter(n -> n % 2 == 0).mapToInt(n -> n).sum();

Convert a list of strings to uppercase:

List<String> upper = strings.stream().map(String::toUpperCase).toList();

Find the longest string in a list:

Optional<String> longest = strings.stream()
    .max(Comparator.comparingInt(String::length));

Concatenate two streams:

Stream<String> combined = Stream.concat(stream1, stream2);

Best Practices & Pitfalls

Avoid Side Effects
Stream operations should be stateless; avoid modifying external variables in lambdas.
Primitive Streams
Performance can be improved using IntStream, LongStream, or DoubleStream for primitive types.
Reusing Streams
Streams are one-time use only; create new ones if needed.
ForEach vs. For-Loops
Prefer forEach for clarity, but avoid it for complex mutations or state modifications.

Scenario-Based Interview programming Questions On Java Streams

How to handle exceptions in streams?
Wrap checked exceptions in a lambda with try-catch or use utility methods like Unchecked:

List<String> result = files.stream().map(file -> { 
    try { 
        return readFile(file); 
    } catch (IOException e) { 
        throw new UncheckedIOException(e); 
    } 
}).toList();

When to use parallel streams?
Use for large volumes of data and CPU-bound tasks but avoid for I/O operations or small datasets.
Why does peek exist?
Used for debugging/logging intermediate stream states, such as peek(System.out::println).

Advanced Coding Challenges

Find the second-largest number in a list:

OptionalInt secondLargest = numbers.stream()
    .distinct()
    .sorted()
    .skip(numbers.size() - 2)
    .findFirst();

Merge two lists of objects into a map (ID → Object):

Map<Integer, Person> idToPerson = people.stream()
    .collect(Collectors.toMap(Person::getId, Function.identity()));

Count occurrences of every word in a list:

Map<String, Long> wordCount = words.stream()
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

These questions cover fundamental programming concepts, best practices, and optimization strategies. Senior developers may also focus on parallel stream effectiveness and custom collectors.

Java 8 coding interview questions

Posted by: Instanceofjava Posted date: January 31, 2025 / comment : 0 Java 8

Java 8 coding questions:

Problem	Solution
Separate Odd and Even Numbers	listOfIntegers.stream().collect(Collectors.partitioningBy(number -> number % 2 == 0));
Remove Duplicates from List	listOfStrings.stream().distinct().toList();
Character Frequency in String	input.chars().mapToObj(c -> (char) c).collect(Collectors.groupingBy(ch -> ch, Collectors.counting()));
Frequency of Array Elements	list.stream().collect(Collectors.groupingBy(element -> element, Collectors.counting()));
Sort List in Reverse	list.sort(Comparator.reverseOrder()); list.forEach(System.out::println);
Join Strings with Prefix/Suffix	list.stream().collect(Collectors.joining("-", "Start-", "-End"));
Filter Multiples of 5	list.stream().filter(number -> number % 5 == 0).forEach(System.out::println);
Merge Arrays and Sort	IntStream.concat(Arrays.stream(arr1), Arrays.stream(arr2)).sorted().toArray();
Merge and Remove Duplicates	IntStream.concat(Arrays.stream(arr1), Arrays.stream(arr2)).distinct().sorted().toArray();
Find Top 3 Minimum Values	list.stream().sorted().limit(3).toList();
Find Top 3 Maximum Values	list.stream().sorted(Comparator.reverseOrder()).limit(3).toList();
Sort Strings by Length	list.stream().sorted(Comparator.comparing(String::length)).forEach(System.out::println);
Sum and Average of Array	int sum = Arrays.stream(inputArray).sum(); double average = Arrays.stream(inputArray).average().orElse(0);
Reverse Integer Array	IntStream.range(0, arr.length).map(i -> arr[arr.length - 1 - i]).toArray();
Check Palindrome	boolean isPalindrome = IntStream.range(0, str.length() / 2).noneMatch(i -> str.charAt(i) != str.charAt(str.length() - i - 1));
Find Second Largest Number	list.stream().sorted(Comparator.reverseOrder()).skip(1).findFirst().orElseThrow();
Common Elements Between Arrays	list1.stream().filter(list2::contains).toList();
Reverse Words in String	Arrays.stream(str.split(" ")).map(word -> new StringBuilder(word).reverse().toString()).collect(Collectors.joining(" "));
Find Strings Starting with Numbers	list.stream().filter(s -> Character.isDigit(s.charAt(0))).toList();
Sum of Digits in Number	String.valueOf(input).chars().map(Character::getNumericValue).sum();
Last Element of List	list.get(list.size() - 1);
Age from Birth Year	Period.between(LocalDate.of(1985, 1, 23), LocalDate.now()).getYears();
Fibonacci Series	Stream.iterate(new int[]{0, 1}, fib -> new int[]{fib[1], fib[0] + fib[1]}).limit(10).map(fib -> fib[0]).toList();

This table properly structures the Java 8 coding problems with their corresponding solutions. Let me know if you need any modifications!

Java 8 Coding Interview Questions and Answers

This document contains a collection of Java 8 coding interview questions along with their answers. These questions focus on key Java 8 features such as Streams, Lambda Expressions, Functional Interfaces, and Method References.

1. Filtering a List and Summing Even Numbers using Streams

Question: Given a list of integers, write a Java 8 program to filter out even numbers and calculate their sum.

Answer:

import java.util.Arrays;
import java.util.List;

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

        int sum = numbers.stream()
                         .filter(n -> n % 2 == 0) // Filter even numbers
                         .mapToInt(Integer::intValue) // Convert to IntStream
                         .sum(); // Calculate sum

        System.out.println("Sum of even numbers: " + sum);
    }
}

Output:

Sum of even numbers: 30

2. Sorting a List of Strings in Ascending and Descending Order

Question: Write a Java 8 program to sort a list of strings in both ascending and descending order.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortStrings {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Charlie");

        // Ascending order
        List<String> ascendingOrder = names.stream()
                                           .sorted()
                                           .collect(Collectors.toList());

        // Descending order
        List<String> descendingOrder = names.stream()
                                            .sorted((s1, s2) -> s2.compareTo(s1))
                                            .collect(Collectors.toList());

        System.out.println("Ascending Order: " + ascendingOrder);
        System.out.println("Descending Order: " + descendingOrder);
    }
}

Output:

Ascending Order: [Alice, Bob, Charlie, John]
Descending Order: [John, Charlie, Bob, Alice]

3. Finding the Maximum and Minimum Values in a List

Question: Write a Java 8 program to find the maximum and minimum values in a list of integers.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class MaxMinValues {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(10, 20, 5, 30, 15);

        Optional<Integer> max = numbers.stream().max(Integer::compareTo);
        Optional<Integer> min = numbers.stream().min(Integer::compareTo);

        System.out.println("Max Value: " + max.orElse(0));
        System.out.println("Min Value: " + min.orElse(0));
    }
}

Output:

Max Value: 30
Min Value: 5

4. Grouping Objects by a Specific Property using Streams

Question: Given a list of Employee

objects, write a Java 8 program to group them by their department.

Answer:

import java.util.*;
import java.util.stream.Collectors;

class Employee {
    private String name;
    private String department;

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    public String getDepartment() {
        return department;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class GroupByDepartment {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("John", "HR"),
            new Employee("Alice", "IT"),
            new Employee("Bob", "HR"),
            new Employee("Charlie", "IT")
        );

        Map<String, List<Employee>> groupedByDepartment = employees.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));

        System.out.println("Employees grouped by department: " + groupedByDepartment);
    }
}

Output:

Employees grouped by department: {HR=[John, Bob], IT=[Alice, Charlie]}

5. Removing Duplicates from a List using Streams

Question: Write a Java 8 program to remove duplicates from a list of integers.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

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

        List<Integer> uniqueNumbers = numbers.stream()
                                             .distinct()
                                             .collect(Collectors.toList());

        System.out.println("Unique Numbers: " + uniqueNumbers);
    }
}

Output:

Unique Numbers: [1, 2, 3, 4, 5]

6. Counting the Frequency of Characters in a String using Streams

Question: Write a Java 8 program to count the frequency of each character in a string.

Answer:

import java.util.Map;
import java.util.stream.Collectors;

public class CharacterFrequency {
    public static void main(String[] args) {
        String input = "java8";

        Map<Character, Long> frequencyMap = input.chars()
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(c -> c, Collectors.counting()));

        System.out.println("Character Frequency: " + frequencyMap);
    }
}

Output:

Character Frequency: {a=2, v=1, j=1, 8=1}

Java 8 subtract N minutes from current date

Posted by: Instanceofjava Posted date: February 05, 2018 / comment : 0 Java 8 , java programming interview questions

Java 8 provides java.time.LocalDateTime class.
By using minusMinutes() methods of LocalDateTime class we can subtract minutes from date or current date in java.
Lets see an example program on how to remove / subtract n minutes from current date using java 8.

package com.instanceofjava.java8;
import java.time.LocalDateTime;
/**
* @author www.Instanceofjava.com
* @category interview programs
*
* Description: subtract minutes to current date using java 8
*
*/
public class AddMinutesToDate {
public static void main(String[] args) {
//create data using java 8 LocalDateTime
LocalDateTime datetime= LocalDateTime.now();
System.out.println("Before subtracting 30 minutes to date: "+datetime);
//add seconds by using minuesMinutes(seconds) method
datetime=datetime.minusMinutes(30);
System.out.println("After subtracting 30 minutes to date: "+datetime);
}
}

Output:

Before subtracting 30 minutes to date: 2018-02-05T22:41:42.463
After subtracting 30 minutes to date: 2018-02-05T22:11:42.463

subtract minutes from java 8 date time.png

How to Add N minutes to current date using java 8

How to Add N minutes to current date using java 8

Posted by: Instanceofjava Posted date: February 05, 2018 / comment : 0 Java 8 , java programming interview questions

Java 8 providing java java.time package which is having more utility methods related to date and time.
LocalDateTime class providing plusMinutes(int minutes) method to add minutes to current date or given date in java.
Lets see an example program to add 30 minutes to current date using java 8 LocalDateTime class.

#1: Java Example program to add 30 minutes to current date

package com.instanceofjava.java8;
import java.time.LocalDateTime;
/**
* @author www.Instanceofjava.com
* @category interview programs
*
* Description: Add minutes to current date using java 8
*
*/
public class AddMinutesToDate {
public static void main(String[] args) {
//create data using java 8 LocalDateTime
LocalDateTime datetime= LocalDateTime.now();
System.out.println("Before adding minutes to date: "+datetime);
//add seconds by using plusMinutes(Minutes) method
datetime=datetime.plusMinutes(30);
System.out.println("After adding 30 minutes to date: "+datetime);
}
}

Output:

Before adding minutes to date: 2018-02-05T22:14:33.664
After adding 30 minutes to date: 2018-02-05T22:44:33.664

Java 8 date add n seconds to current date example program

Can we define default methods in functional interfaces in java 8

Posted by: Instanceofjava Posted date: February 05, 2018 / comment : 0 Java 8 , java programming interview questions

Functional interfaces in java 8 will have single abstract method in it.
Check below two pages regarding defining and using functional interfaces using Lamda expressions.
Java 8 functional interface with example
Implement java 8 functional interface using lambda example program
We can define default methods in functional interfaces in java 8.
But every functional interface must have single abstract method in it.
As we know that default methods should have a implementation as they are not abstract methods.
Lets see an example program on defining functional interface with default method.

#1: Java example program to create functional interface with default method.

package com.instanceofjava.java8;
/**
* @author www.Instanceofjava.com
* @category interview programming questions
*
* Description: java 8 functional interfaces
*
*/
@FunctionalInterface
public interface FunctionalInterfaceExample {
void show();
//default method
default void message() {
System.out.println("hello this is default method in functional interface");
}
}

#2: Java Example program on how to implement functional interface abstract method and use default method.

Can we define default methods in functional interfaces in java 8

Can we define multiple abstract methods in functional interface ?
Functional interface with multiple abstract methods in java 8
Can we define multiple default method inside a functional interface.
Yes, We can define multiple default methods inside a functional interface

Functional interface with multiple methods in java 8

Posted by: Instanceofjava Posted date: February 04, 2018 / comment : 0 Java 8 , java programming interview questions

Functional interfaces will contains single abstract method with @FunctionalInterface annotation.
Check below two posts for defining functional interface and implementing functional interface method using Lamda in java 8.
Java 8 functional interface with example
Implement java 8 functional interface using lambda example program
Now the question is can we declare or define multiple abstract methods in one functional interface in java 8.
No. Functional interface should contain only one abstract method so that Lamda will implement it.
Lets see what happens if we define multiple abstract methods inside a functional interface
Note: all methods inside any interface by default abstract methods.

package com.instanceofjava.java8;
/**
* @author www.Instanceofjava.com
* @category interview programming questions
*
* Description: java 8 functional interfaces
*
*/
@FunctionalInterface
public interface FunctionalInterfaceExample {
//compile time error: Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is
not a functional interface
void show();
void calculate();
}

If we define multiple abstract methods inside a functional interface it will throw a compile time error.
Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is not a functional interface

Implement java 8 functional interface using lambda example program

Posted by: Instanceofjava Posted date: February 04, 2018 / comment : 0 Java 8 , java programming interview questions

Functional interfaces introduces in java 8 .
Functional interfaces will have single abstract method in it.
Check here for full details on Java 8 functional interface with example.
Functional interfaces will be implemented by java 8 Lamda expressions.
Lets see an example program on how can we use functional interfaces or how can we implement functional interfaces using Lamda expression in java 8.
Create one functional interface with one abstract method in it.
Create a class and implement this abstract method using Lamda Expressions.

#1: Java example program to create functional interface.

functional interface example in java 8 using lamda expressions

#2: Java example program to implement functional interface using Lamda expressions in java 8.

package com.instanceofjava.java8;
/**
* @author www.Instanceofjava.com
* @category interview programming questions
*
* Description: java 8 Lamda expressions
*
*/
public class LamdaExpressions {
public static void main(String[] args) {
FunctionalInterfaceExample obj = ()->{
System.out.println("hello world");
};
obj.show();
}
}

Output:

hello world

Java 8 functional interface with example

Posted by: Instanceofjava Posted date: February 04, 2018 / comment : 0 Java 8 , java programming interview questions

Java 8 introduced Lamda expressions and functional interfaces.
An interface with one abstract method is known as functional interfaces.
Functional interfaces in java 8 marked with @FunctionalInterface.
These functional interfaces implementation will be provided by Lamda expressions.
Default methods in java 8 interfaces are not abstract methods. But we can define multiple default methods in functional interface.
Java 8 functional interface example program

#1: Java Example program to create java 8 functional interface.

package com.instanceofjava.java8;
/**
* @author www.Instanceofjava.com
* @category interview programming questions
*
* Description: java 8 functional interfaces
*
*/
@FunctionalInterface
public interface FunctionalInterfaceExample {
void show();
}

Can we create functional interface with @FunctionalInterface annotation without any single abstract method?
No. Functional interfaces must have single abstract method inside it.
It will throw compile time error : Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is not a functional interface.
Lets see an example program on this so that we can conclude it.
How to use these functional interfaces we will discuss in next post on Lamda expressions.
Implement java 8 functional interface using lambda example program

#2: What will happend if we define functional interface without a single abstract method in it?

Java 8 date add n seconds to current date example program

Posted by: Instanceofjava Posted date: February 03, 2018 / comment : 0 Java 8 , java programming interview questions

Java 8 providing java.time.LocalDateTime class.
By using plusSeconds() method of LocalDateTime we can add seconds to date.
By Using minusSeconds() method we can substract seconds from java date.
Lets see an example java program to add n seconds to current date and minus / subtract n seconds from java 8 date.

#1: Java Example program to add n seconds to current date using java 8.

package com.instanceofjava.java8;
import java.time.LocalDateTime;
/**
* @author www.Instanceofjava.com
* @category interview programs
*
* Description: java seconds to java 8 date
*
*/
public class addSecondsToDate {
public static void main(String[] args) {
//create data using java 8 LocalDateTime
LocalDateTime datetime= LocalDateTime.now();
System.out.println("Before: "+datetime);
//add seconds by using plusSeconds(seconds) method
datetime=datetime.plusSeconds(12);
System.out.println("After: "+datetime);
}
}

Output:

2018-02-03T20:19:25.760
2018-02-03T20:19:37.760

#2: Java Example program to subtract n seconds to current date using java 8.

java 8 date subtract seconds example program

Java 8 foreach example program

Posted by: Instanceofjava Posted date: January 31, 2018 / comment : 0 Java 8 , java interview programs

Java 8 introduces for each loop.
before that lest see an example of how normal java for each loop.

#1: Java Example program which explain use of for each loop.

package com.instanceofjava.java8;
import java.util.HashMap;
import java.util.Map;
public class ForEachLoop {
/**
* @author www.Instanceofjava.com
* @category interview questions
*
* Description: java 8 for each loop
*
*/
public static void main(String[] args) {
Map<String, Integer> stumarks = new HashMap<>();
stumarks.put("Sai", 65);
stumarks.put("Vamshi", 65);
stumarks.put("Mahendar", 76);
stumarks.put("Muni", 87);
stumarks.put("Manohar", 90);
for (Map.Entry<String, Integer> entry : stumarks.entrySet()) {
System.out.println(entry.getKey() + " marks : " + entry.getValue());
}
}
}

Output:

Muni marks : 87
Vamshi marks : 65
Mahendar marks : 76
Sai marks : 65
Manohar marks : 90

#2: Java Example program which explains the use of for each loop in java 8

In the above program we used for each loop to get key value pairs of map.
Same thing will be done in java 8 by using stumarks.forEach((k,v)->System.out.println( k + " marks : " + v));

Java 8 java.util.function.Function with example program

Posted by: Instanceofjava Posted date: January 30, 2018 / comment : 1 Java 8 , java programming interview questions

java.util.function.Function introduced in java 8 for functional programming.
Function(T,R) will be used in streams where to take one type of object and convert to another and return.
And this Function() supports methods like apply(), andThen(), compose() and identity() etc.
Lets see an example on java.util.function.Function.

#1: Java Example program on java.util.function.Function

package com.instanceofjava.java8;
import java.util.function.Function;
/**
* @author www.Instanceofjava.com
* @category interview questions
*
* Description: java 8 java.util.function.Function example program
*
*/
public class Java8Function {
public static void main(String[] args) {
Function<Integer, String> function = (n) -> {
return "Number received: "+n;
};
System.out.println(function.apply(37));
System.out.println(function.apply(64));
}
}

Output:

Number received: 37
Number received: 64

#2: Java example program on Function and explain used of addThen() and compose() methods

How to subtract minutes from current time in java

Posted by: Instanceofjava Posted date: October 19, 2017 / comment : 0 Java 8 , java programming interview questions

We have discussed about how to subtract hours from java 8 using LoclaDateTime class in java.
How to subtract N hours from current date time using java 8
Now we will see how to subtract minutes from current date time in java.
How to subtract minutes from current time in java / How to subtract minutes from time in java.
Lets see an example java program which will subtract minutes from java date time
How to subtract minutes from current time in java

Program #1 : Java Example Program to subtract minutes from given string formatted date time using java 8.

package java8;
/**
* By: www.instanceofjava.com
* program: how to subtract minutes from date time using java 8
*
*/
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class SubtractMinutesJava{
public static void main(String[] args) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String currentTime= "2017-10-19 22:00:00";
System.out.println("Before subtraction of minutes from date: "+currentTime);
LocalDateTime datetime = LocalDateTime.parse(currentTime,formatter);
datetime=datetime.minusMinutes(30);
String aftersubtraction=datetime.format(formatter);
System.out.println("After 30 minutes subtraction from date: "+aftersubtraction);
}
}

Output:

Before subtraction of minutes from date: 2017-10-19 22:00:00
After 30 minutes subtraction from date: 2017-10-19 21:30:00

Program #2 : Java Example Program to subtract seconds from given string formatted date time using java 8.

package java8;
/**
* By: www.instanceofjava.com
* program: how to subtract seconds from date time using java 8
*
*/
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class SubtractSecondsJava{
public static void main(String[] args) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String currentTime= "2017-10-19 22:00:00";
System.out.println("Before subtraction of seconds from date time: "+currentTime);
LocalDateTime datetime = LocalDateTime.parse(currentTime,formatter);
datetime=datetime.minusSeconds(30);
String aftersubtraction=datetime.format(formatter);
System.out.println("After 30 seconds subtraction from date time: "+aftersubtraction);
}
}

Output:

Before subtraction of seconds from date time: 2017-10-19 22:00:00
After 30 seconds subtraction from date time: 2017-10-19 21:59:30

Program #3 : Java Example Program to subtract seconds from current date time using java 8.

how to subtract minutes from java date time

Java 8 Interface Static and Default Methods

Posted by: Instanceofjava Posted date: February 22, 2015 / comment : 2 Java 8 , Java SE

Java 8 introduced two new methods in interface they are
1.default methods
2.static methods
By this interfaces and abstract class are same but still having lot differences like abstract class can have a constructor etc will discuss more before that we need to know about these Java 8 features of interfaces.
Defaults methods are also called as defender methods can be implemented inside the interface
Like normal class now with java 8 we can declare static methods in side a interface.
Lets jump deep into Java 8 default and static methods

1.Interface Default Methods in Java 8

Before Java 8 in interfaces we can and able to declare only abstract methods only.
If we declare a method without abstract that will be treated as abstract by default.
As we know all methods in interfaces are by default abstract methods.
These methods wont have body means implementations
The class which is implementing this interface need to provide body / implementation for this abstract methods.
Now with java 8 default methods we can add methods to interface without disturbing existing functionality.
So instead of overriding now we can inherit these default methods from interfaces

Defaults methods are also known as defender methods or virtual extension methods
Default methods will help us to avoid utility classes.
We can define utility methods inside the interface and use it in all classes which is implementing.
One of the major reason to introduce this default methods in java 8 is to support lambda expressions in collections API and to enhance.

package com.instanceofjava;
interface Java8Interface{
abstract void show();
default void display(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Sample implements Java8Interface {
void show(){
System.out.print("overridden method ")
}
public static void main(String[] args){
Sample obj= new Sample();
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name
}
}

Output:

overridden method
default method of interface
default method of interface

How to call default methods:

We can all these default methods by using interface name and also by using object of the class which is implementing.
From above example
obj.show(); // calling implemented method
obj.display(); // calling inherited method
Java8Interface.display(); calling using interface name

Can we override java 8 default method

As we discussed above default methods in interfaces are implemented methods with bodies
Yes we can override same method in class which is implementing this interface.
Lets see one sample program how to override and what happens if we override

package com.instanceofjava;
interface InterfaceWithDefault{
default void defMethod(){
System.out.println("default method of interface");
}
}

package com.instanceofjava;
class Demo implements InterfaceWithDefault{
void defMethod(){
System.out.print("overridden method in class Demo ")
}
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod(); // calling overridden method
Java8Interface.defMethod(); calling using interface name : interface defMethod will be called
}
}

Output:

overridden method in class Demo
default method of interface

What happens if we implement two interfaces having same default methods

Now lets see if a class implementing two interfaces which are having same default methods
Whatever the implementation in the two interfaces defined if we implementing two interfaces which are having a default method in both then compilation error will come if two methods have same signature. works fine if two methods have same name with different arguments.
Check the below example programs to understand more.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(){
System.out.println("default method of interface: B");
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
}
}

If we implement two interfaces which are having same method with same parameters then compilation error will occur.
Duplicate default methods named "defMethod" with the parameters () and () are inherited from the types A and B.
If we define two methods with different type of parameters then we can work with both interfaces.

package com.instanceofjava;
interface A{
default void defMethod(){
System.out.println("Default method of interface: A");
}
}

package com.instanceofjava;
interface B{
default void defMethod(String str){
System.out.println("Default method of interface: B");
System.out.println(str);
}
}

package com.instanceofjava;
class Demo implements A, B{ // compilation error will come
public static void main(String[] args){
Demo obj= new Demo();
obj.defMethod();
obj.defMethod("Java 8")
}
}

Output:

Default method of interface: A
Default method of interface: B
Java 8

1.Interface Static Methods in Java 8

Another Java 8 interface method is static method.
Now we can define static methods inside interface but we can not override these static methods.
These static method will act as helper methods.
These methods are the parts of interface not belongs to implementation class objects.

package com.instanceofjava;
interface StaticInterface{
Static void print(String str){
System.out.println("Static method of interface:"+str);
}
}

package com.instanceofjava;
class Demo implements StaticInterface{
public static void main(String[] args){
StaticInterface.print("Java 8")
}
}

Output:

Static method of interface: Java 8

8 New Java 8 Features

Posted by: Instanceofjava Posted date: February 16, 2015 / comment : 1 Java 8 , Java SE

Default and Static methods in Interface
Lambda Expressions
Optional
Streams
Method References
Data Time API
Nashorn Javascript Engine
Parallel Arrays

1.Default and Static methods in Interface :

Java 8 introduces new features to interfaces.
Before java 8 interface having only abstract methods but now java 8 added two more type of methods to interface !.
First one is default method. A method which is having a default keyword with method body.
Actually interfaces wont have any implemented methods but now with java 8 default method we can add a method with default implementation by using "default " keyword.
The classes which are implementing this interface can use these default method and same time it can override the existing method. But its not mandatory to override.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
}

The second new method introduced in java 8 is static method.
Yes like in classes now we can define a static methods inside interface by using "static".
Basically static methods which are defined in interface are interface level only. if we want to call these static methods which are defined in interfaces we need to use interface name so that we can access these methods.

package com.instanceofjava;
interface Java8InterfaceDemo{
abstract void add();
default void display(){
System.out.println("default method of interface");
}
public static void show(){
System.out.println("static method of interface");
}
}

2.Lambda Expressions

One of the most awaited and biggest release in java 8 is lamda expressions.
Ability to pass functionality/ behavior to methods as arguments.
Allows us to write a method in the same place we are going to use it.

package com.instanceofjava;
interface JavalamdaExpression{
public static void main(String[] args){
Arrays.asList( "j", "a", "v" ,"a","8").forEach( e -> System.out.print( e ) );
// java8
}
}

3.java.util.Optional:

One of the best and cool feature of java 8 is Optional class. Which is a final calls from java.util package.
The major repeating statement in every project is checking "NullPointerException". Before using any object we need to check whether it is null or not if its not null then only we need to proceed.
Optional is just like a container which holds a value of type <T> or "null". By using isPresent() method of Optional class we can check particular object is null not not.

package com.instanceofjava;
import java.util.Optional:
class Java8OptionalDemo{
public static void main(String[] args ){
Optional< String > str = Optional.ofNullable( null );
System.out.println( "str having value ? " + str.isPresent() ); // output : str having value ? false
}
}

4.Streams:

One of the excellent feature from java 8 as java.util.stream.
Stream API introduces real-world functional-style programming into the Java.
Provides functional operations on stream of elements such as list , set and map
Supports filtering, mapping and removal of duplicates of elements in collections, are implemented lazily.
Now we can get Streams from collections, arrays and bufferedReaders etc.

package com.instanceofjava;
import java.util.Arrays;
class Java8StreamsDemo{
public static void main(String[] args ){
Arrays.stream(new int[] {1, 2, 3,4,5})
.map(n -> 2 * n + 1)
.average()
.ifPresent(System.out::println); // output: 7.0
}
}

5.Method Reference:

We can use lambda expressions to create anonymous methods.
Sometimes, however, a lambda expression does nothing but call an existing method.
In those cases, it's often clearer to refer to the existing method by name.
Using Method references refer to the existing method by name, they are compact, easy-to-read lambda expressions for methods that already have a name

package com.instanceofjava;
import java.util.Arrays;
class Java8MethodRef{
public void show(String str){
System.out.println(str);
}
public static void main(String[] args ){
Arrays.asList("a", "b", "c").forEach(new A()::show); // a b c
}
}

6.Data Time API

The next cool feature from java 8 is new date time API(jsr 310) added within java.time package.
Before java 8 if we want to format dates we use SimpleDateFormatter class in java 8 while declaring date itself it has constructor to pass format of date.
Some of the new classes introduced in java 8 date time are as follows.

LocalTime
LocalDate
LocalDateTime
OffsetDate
OffsetTime
OffsetDateTime

package com.instanceofjava;
import java.util.Arrays;
class Java8DateTimeAPI{
public static void main(String[] args ){
LocalDate currentDate = LocalDate.now();
System.out.println(currentDate);
LocalDate twentyMarch2015 = LocalDate.of(2015, Month.MARCH, 06);
System.out.println(twentyMarch2015); //2015-03-06
LocalDate firstApril2015 = LocalDate.of(2015, 4, 1);
System.out.println(firstApril2015);//2015-04-01
}
}

7.Nashorn Javascript Engine

Java 8 come with new Nashorn Javascript Engine which is allowing us to develop and run JavaScript applications.

package com.instanceofjava;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( "JavaScript" );
System.out.println( engine.getClass().getName() );
System.out.println( "output:" + engine.eval( "function show() { return 10; }; show();" ) );
}
}

jdk.nashorn.api.scripting.NashornScriptEngine
output:10

8.Parallel Array Sorting

As of now java 7 we already having Arrays.sort() method to sort objects now java 8 introduced parallel sorting which has more speed than arrays.sort() and follows Fork/Join framework introduced in Java 7 to assign the sorting tasks to multiple threads that are available in the thread pool.
Java 8 added parallel sorting functionalities to java.util.Arrays to take advantage of multithread machines

package com.instanceofjava;
import java.util.Arrays;
class Java8JavaScript{
public static void main(String[] args ){
int arr[]={1,4,2,8,5};
Arrays.parallelSort(arr);
for(int i:arr){
System.out.println(i);
}
}
}