Java 8 introduced several new features and improvements, including lambda expressions, functional interfaces, streams, and default methods in interfaces. Here are some scenario-based interview questions with real-time examples that demonstrate the usage of these Java 8 features:
1. Lambda Expressions
Question: How would you use lambda expressions to implement a functional interface?
Example:
// Functional interface
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}
public class LambdaExample {
public static void main(String[] args) {
// Lambda expression to implement the Calculator interface
Calculator addition = (a, b) -> a + b;
// Using the lambda expression
int result = addition.calculate(5, 3); // Result: 8
System.out.println("Addition result: " + result);
}
}
2. Streams API
Question: How can you use Streams API to filter and collect elements from a list?
Example:
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("Apple", "Orange", "Banana", "Grape", "Pineapple");
// Using Stream API to filter and collect elements
List<String> filteredFruits = fruits.stream()
.filter(fruit -> fruit.length() > 5)
.collect(Collectors.toList());
System.out.println("Filtered fruits: " + filteredFruits); // Output: [Orange, Pineapple]
}
}
3. Functional Interfaces and Method References
Question: Explain how method references can be used with functional interfaces.
Example:
import java.util.function.Consumer;
public class MethodReferenceExample {
public static void main(String[] args) {
// Using method reference to implement a Consumer functional interface
Consumer<String> printer = System.out::println;
// Using the Consumer interface
printer.accept("Hello, World!"); // Output: Hello, World!
}
}
4. Default Methods in Interfaces
Question: How do default methods in interfaces improve API design and backward compatibility?
Example:
interface Greeting {
default void greet() {
System.out.println("Hello, Guest!");
}
}
class Guest implements Greeting {
// No need to override the default method unless necessary
}
public class DefaultMethodExample {
public static void main(String[] args) {
Guest guest = new Guest();
guest.greet(); // Output: Hello, Guest!
}
}
5. Optional Class
Question: When would you use the Optional class and how does it prevent null pointer exceptions?
Example:
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
String value = "Java 8 Optional Example";
// Creating an Optional
Optional<String> optionalValue = Optional.ofNullable(value);
// Using Optional to prevent null pointer exception
if (optionalValue.isPresent()) {
System.out.println(optionalValue.get()); // Output: Java 8 Optional Example
} else {
System.out.println("Value is null");
}
}
}
6. Parallel Streams
Question: How can you leverage parallel streams to improve performance in Java applications?
Example:
import java.util.Arrays;
public class ParallelStreamExample {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// Using parallel stream to perform operations concurrently
int sum = Arrays.stream(numbers)
.parallel()
.sum();
System.out.println("Sum of numbers: " + sum); // Output: Sum of numbers: 55
}
}
7. Date and Time API (java.time)
Question: How does the java.time API improve upon the legacy Date and Calendar classes?
Example:
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class DateTimeExample {
public static void main(String[] args) {
// Formatting date using DateTimeFormatter
LocalDate today = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");
String formattedDate = today.format(formatter);
System.out.println("Formatted Date: " + formattedDate); // Output: Formatted Date: 30-06-2024
}
}
Conclusion
These Java 8 scenario-based interview questions with real-time examples cover fundamental concepts such as lambda expressions, streams, functional interfaces, default methods in interfaces, Optional class, parallel streams, and the java.time API. Understanding these features and being able to demonstrate their usage in practical scenarios will showcase your proficiency in modern Java development and prepare you effectively for Java 8-focused interviews.
.png)