CoreJava-Java8 Features

Java 8

 

1.       What are the main features introduced in Java 8?

Answer: Java 8 introduced several significant features, including Lambda expressions, Functional interfaces, Stream API, Default methods in interfaces, and the new Date and Time API (java.time package).

Lambda expressions -  are anonymous functions that allow you to treat functionality as a method argument, or code as data. They provide a concise way to represent a method interface using a single abstract method (SAM).

Functional interfaces -  are interfaces that have exactly one abstract method and may have any number of default or static methods. They are the target of lambda expressions and method references.

Stream API -  is a powerful tool to process collections of data in a functional programming style. It allows you to perform aggregate operations (like filtering, mapping, reducing) on collections with ease.

Default methods -  in interfaces allow adding new methods to interfaces without breaking existing implementations. This feature enables backward compatibility for the existing codebases.

Date and Time API -  (java.time package) provides a more comprehensive, flexible, and intuitive way to handle date and time manipulation.

2.       What is a Lambda expression? Explain with an example.

Answer: A lambda expression is a concise way to represent a single abstract method (functional interface) as an instance of a functional interface. It allows you to pass behavior as a method argument, making the code more expressive and readable.

Example: Let's say we have a functional interface called MathOperation with a single abstract method int operate(int a, int b).

interface MathOperation {

    int operate(int a, int b);

}

Using a lambda expression, we can define an instance of this functional interface as follows:

MathOperation addition = (a, b) -> a + b;

Here, the lambda expression (a, b) -> a + b represents the implementation of the operate method for addition.

 

3.       How are lambda expressions used with the Stream API? Provide an example.

Answer: Lambda expressions work seamlessly with the Stream API to perform operations on collections of data.

Example: Let's consider a list of integers and we want to filter the even numbers, double each element, and then find their sum.

import java.util.Arrays;

import java.util.List;

 

public class StreamExample {

    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(n -> n * 2)       // Double each element

                        .sum();                     // Calculate the sum

 

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

    }

}

In this example, the filter, mapToInt, and sum methods are used with lambda expressions as arguments to perform the required operations.

 

4.       What are functional interfaces, and why are they important in the context of lambda expressions?

Answer: Functional interfaces are interfaces that have only one abstract method. They are used as the target for lambda expressions and method references. Functional interfaces provide a way to represent a block of code as a value, which is essential for using lambda expressions.

Example: Runnable is a functional interface with a single abstract method void run().

public class FunctionalInterfaceExample {

    public static void main(String[] args) {

        Runnable runnable = () -> System.out.println("Hello, I'm a functional interface!");

        new Thread(runnable).start();

    }

}

Here, we've used a lambda expression to implement the run method of the Runnable functional interface and used it to create a new thread.

5.       Explain the Date and Time API in Java 8 with an example of parsing and formatting dates.

Answer: The Date and Time API (java.time package) introduced in Java 8 provides a more intuitive and thread-safe way to handle dates and times.

Example: Suppose we want to parse a date string in a specific format, convert it to a different format, and then display it.

import java.time.LocalDate;

import java.time.format.DateTimeFormatter;

 

public class DateTimeExample {

    public static void main(String[] args) {

        // Parsing date from a string

        String dateString = "2023-08-03";

        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        LocalDate date = LocalDate.parse(dateString, dateFormatter);

 

        // Formatting date to a different format

        DateTimeFormatter newDateFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");

        String formattedDate = date.format(newDateFormatter);

 

        System.out.println("Original date: " + dateString);

        System.out.println("Formatted date: " + formattedDate);

    }

}

In this example, we used DateTimeFormatter to parse the date from the string in one format, and then we formatted it into another format using the same DateTimeFormatter.