Java 8 interview questions

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

Answer: Java 8 introduced several significant features, including:

• Lambda Expressions: Enables functional programming by allowing concise expression of instances of single-method interfaces (functional interfaces).
• Stream API: Provides a functional approach to processing sequences of elements, enabling operations such as map, filter, and reduce.
• Default and Static Methods: Allows the definition of default methods in interfaces, enabling new methods to be added to interfaces without breaking existing implementations.
• Optional: A container class to handle null values more gracefully, providing methods to check the presence of a value and retrieve it.
• New Date and Time API: A new set of classes in the java.time package to replace the old java.util.Date and java.util.Calendar classes with more comprehensive and flexible options.
• Nashorn JavaScript Engine: A new lightweight JavaScript engine integrated into Java to execute JavaScript code.
• Method References: A shorthand notation of a lambda expression to call a method by name.
• Functional Interfaces: Special types of interfaces with a single abstract method, used as the basis for lambda expressions.
• Collectors Class: A utility class for collecting stream elements into various data structures and performing aggregate operations.
• Improvements to ConcurrentHashMap: Enhancements for better performance and additional methods for aggregate operations.

2. What is a functional interface in Java 8?

Answer: A functional interface is an interface that contains exactly one abstract method. They can have any number of default or static methods. Functional interfaces are used as the basis for lambda expressions. The @FunctionalInterface annotation can be used to indicate that an interface is intended to be a functional interface. Examples include Runnable, Callable, Comparator, and custom interfaces.

3. What is a lambda expression and why is it used?

Answer: A lambda expression is a feature in Java 8 that provides a clear and concise way to represent a method interface using an expression. It's used to enable functional programming and reduce the amount of boilerplate code.

Example:

// Without lambda
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
};
// With lambda
Runnable runnable = () -> System.out.println("Running");

4. How do lambda expressions benefit Java?

Answer: Lambda expressions bring several benefits to Java:

• Conciseness: They allow writing more concise and readable code by eliminating the need for boilerplate code, such as anonymous class declarations.
• Functional Programming: They enable functional programming techniques, allowing more expressive and flexible code.
• Parallel Processing: Lambda expressions, combined with the Stream API, facilitate parallel processing of data collections.

5. Can you explain the Stream API in Java 8?

Answer: The Stream API is a powerful addition to Java 8 that provides a high-level abstraction for processing sequences of elements (collections). It supports operations such as filter, map, reduce, find, match, and more. Streams can be created from collections, arrays, or I/O channels and can be processed in a declarative manner, often improving code readability and maintainability. Streams can be either sequential or parallel, enabling efficient parallel processing of large datasets.

Example:

List<String> strings = Arrays.asList("a", "b", "c", "d");
List<String> result = strings.stream()
    .filter(s -> s.contains("a"))
    .collect(Collectors.toList());

6. What is the difference between findFirst() and findAny() methods in the Stream API?

Answer:

findFirst(): Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. If the stream has defined encounter order, then findFirst() will return the first element in that encounter order.

List<String> list = Arrays.asList("one", "two", "three", "four", "five");
Optional<String> firstWord = list.stream().findFirst();
System.out.println(firstWord.orElse("No word found")); // Prints: one

findAny(): Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. The behavior of findAny() is explicitly nondeterministic; it is free to select any element of the stream. It means in parallel operations, this method is not constrained to return the first element.

Optional<String> anyWord = list.stream().findAny();
System.out.println(anyWord.orElse("No word found")); // Prints: one

In the above example, we used the so-called "sequential" stream that's why the output of findAny() and findFirst() is the same ("one"). But if we used "parallel" stream the results might be different:

Optional<String> anyWordParallel = list.parallelStream().findAny();
System.out.println(anyWordParallel.orElse("No word found")); // Prints: not necessarily one, might be any word from the list

In a parallel stream, the Java runtime partitions the stream into multiple sub-streams. Aggregate operations iterate over and process these sub-streams in parallel. So findAny() might return any element from the stream in a parallel execution, depending on which sub-stream finishes first.

7. How do you handle null values using the Optional class?

Answer: The Optional class in Java 8 is designed to handle optional values and prevent NullPointerException. It provides methods such as:

• isPresent(): Checks if a value is present.
• ifPresent(Consumer<? super T> action): Executes the given action if a value is present.
• orElse(T other): Returns the value if present, otherwise returns the specified default value.
• orElseGet(Supplier<? extends T> other): Returns the value if present, otherwise invokes the specified supplier and returns the result.
• orElseThrow(Supplier<? extends X> exceptionSupplier): Returns the value if present, otherwise throws an exception provided by the supplier.

Example:

Optional<String> optional = Optional.of("Hello");
optional.ifPresent(System.out::println); // prints "Hello"

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.isPresent()); // prints "false"

8. What are default methods in interfaces and why were they introduced in Java 8?

Answer: Default methods in interfaces are methods with a default implementation. They were introduced to allow the addition of new methods to interfaces without breaking the existing implementations. This is particularly useful for evolving APIs and maintaining backward compatibility. Default methods are declared using the default keyword.

Example:

interface MyInterface {
    default void myDefaultMethod() {
        System.out.println("Default implementation");
    }
}

9. Can you give an example of a method reference in Java 8?

Answer: Method references provide a way to refer to methods without invoking them. They can be used as a shorthand for a lambda expression that only calls a method. There are four types of method references:

• Static method reference: ClassName::staticMethodName
• Instance method reference of a particular object: instance::instanceMethodName
• Instance method reference of an arbitrary object of a particular type: ClassName::instanceMethodName
• Constructor reference: ClassName::new

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println); // Method reference to print each name

10. Explain the significance of the Collectors class in the Stream API.

Answer: The Collectors class provides a variety of reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, and more. It is part of the java.util.stream package and offers methods like toList(), toSet(), toMap(), joining(), groupingBy(), partitioningBy(), and more. Collectors are often used at the end of a stream pipeline to transform the processed elements into a desired data structure.

11. What are the differences between map() and flatMap() methods in the Stream API?

Answer:

• map(Function<? super T, ? extends R> mapper): Transforms each element of the stream into another object via the provided mapping function. It produces a stream of transformed elements, with each input element being mapped to exactly one output element.
• flatMap(Function<? super T, ? extends Stream<? extends R>> mapper): Similar to map(), but the mapping function produces a stream of new values, which are then flattened into a single stream. This is useful for handling nested collections or converting a stream of streams into a single stream of elements.

Example:

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("a", "b", "c"),
    Arrays.asList("d", "e", "f")
);

// Using map() results in a stream of lists
Stream<Stream<String>> mappedStream = nestedList.stream().map(List::stream);

// Using flatMap() results in a stream of elements
Stream<String> flatMappedStream = nestedList.stream().flatMap(List::stream);

12. What are the improvements made to ConcurrentHashMap in Java 8?

Answer: Java 8 introduced several enhancements to ConcurrentHashMap, including:

• Introduction of methods like forEach, reduce, and search for performing aggregate operations.
• Better performance with the use of internal data structures and algorithms.
• Support for parallelism by leveraging ForkJoinPool.

13. How does the new Date-Time API (java.time) in Java 8 improve date and time handling?

Answer: The new Date-Time API in Java 8 provides a more comprehensive and flexible set of classes for date and time manipulation. It overcomes the flaws of the old java.util.Date and java.util.Calendar classes by being immutable, type-safe, and providing better APIs.

Example:

LocalDate date = LocalDate.now();
LocalDateTime dateTime = LocalDateTime.of(2023, Month.MAY, 27, 14, 33);
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("America/New_York"));

in topics ko ache se discribe kro

concurrency

BiConsumer

functionInterface

abstract method

n nuber of default and static method

@FunctionalInterface Runnable class{}