Java 8 interview questions with answers for experience upto 8yrs

1. Given a large list of numbers, you want to find the sum of the squares of even numbers. How would you optimize the code using Java 8 features to avoid unnecessary computations?

Use the Stream API with short-circuiting operations and parallel processing:

int sum = numbers.stream() .parallel() // Enable parallel processing .filter(n -> n % 2 == 0) // Filter even numbers .mapToInt(n -> n * n) // Square each number .sum(); // Sum the results

The .parallel() improves performance on multi-core systems.
The filter() operation reduces the size of the dataset early.
mapToInt() directly converts to an IntStream to avoid unnecessary boxing/unboxing.

2. What is the difference between a HashMap and a ConcurrentHashMap?

HashMap is not thread-safe, and if multiple threads access it simultaneously, it must be synchronized externally.

ConcurrentHashMap is thread-safe and provides better concurrency by locking only portions of the map (bucket-level locking), thus allowing multiple threads to read and write without blocking.

3. Given two interfaces with the same default method signature. How would you resolve the ambiguity in a class implementing both interfaces?

Must override the conflicting default method in the implementing class, and specify which interface’s method user want to call using Interface.super.

interface A { default void display() { System.out.println(“A’s display”); } } interface B { default void display() { System.out.println(“B’s display”); } } class MyClass implements A, B { @Override public void display() { A.super.display(); // Resolving conflict } }

4. Explain the concept of a Functional Interface in Java.

A functional interface is an interface with only one abstract method, but it can have multiple default or static methods. It is typically used as the type of a lambda expression. Examples include Runnable, Callable, Comparator, and Java 8’s Function, Consumer, Supplier, etc. The @FunctionalInterface annotation is used to ensure an interface is functional./p>

5. How can we achieve thread-safety in Java 8 streams?

Streams are generally not thread-safe. However, operations on streams can be performed in parallel using the parallelStream() method, which splits the workload into multiple threads internally. For truly thread-safe operations, one must ensure the source and any intermediate results are handled properly, typically using collectors that work well in a multi-threaded context, like Collectors.toConcurrentMap().

6. Is it safe to use mutable data structures like ArrayList in a parallel stream? If not, how would you ensure thread safety?

No, it is not safe to use mutable data structures in parallel streams because the operations might not be synchronized. To ensure thread safety, you should use thread-safe collections like Collections.synchronizedList() or use collectors designed for concurrent modifications like Collectors.toConcurrentMap().

For example:

List<Integer> numbers = Collections.synchronizedList(new ArrayList<>()); IntStream.range(0, 1000).parallel().forEach(numbers::add); Or: ConcurrentMap<Integer, String> map = Stream.of(1, 2, 3, 4) .collect(Collectors.toConcurrentMap(i -> i, i -> “Value ” + i));

7. How does the reduce() method in Streams work?

reduce() is a terminal operation that combines the elements of a stream into a single result. It applies a binary operator to each element and returns the final result, often used for aggregation like summing or concatenating elements.

8. How would you handle a scenario where a method returns null frequently, and you want to avoid NullPointerException?

Use Optional to avoid NullPointerException and provide a safe way to handle potential null values.

public Optional<String> findNameById(int id) { String name = database.getNameById(id); return Optional.ofNullable(name); } Optional<String> name = findNameById(1); name.ifPresent(System.out::println); // Only prints if name is not null

Optional provides methods like ifPresent(), orElse(), orElseGet(), and orElseThrow() to handle null values effectively.

9. What is the difference between findFirst() and findAny() in streams?

findFirst() returns the first element of the stream, while findAny() may return any element, especially useful in parallel streams where performance benefits can be achieved by not waiting for the first element.

10. What is a WeakReference in Java?

A WeakReference allows the referenced object to be garbage collected when no strong references exist. It’s often used in caching to prevent memory leaks, allowing the object to be collected if needed.

11. How would you sort a list of objects by multiple fields in Java 8?

Use Comparator.comparing() with thenComparing() for multi-field sorting:

List<Person> people = getPeople(); people.stream() .sorted(Comparator.comparing(Person::getLastName) .thenComparing(Person::getFirstName)) .forEach(System.out::println);

This first sorts by lastName and then by firstName.

12. How would you improve the performance of a stream operation that processes a large dataset?

Use parallelStream() for parallel processing.
Use limit() and skip() to process only a part of the dataset.
Use Collectors.toMap() with a merge function to handle large datasets efficiently in Map operations.

For example, processing only the first 10 items:

list.stream().limit(10).forEach(System.out::println); list.stream().limit(10).forEach(System.out::println);

13. What is the use of Collectors.groupingBy() in streams?

Collectors.groupingBy() is used to group the elements of a stream by a classifier function. It returns a Map where the keys are the result of applying the classifier and the values are Lists of items corresponding to each key.

14. How does method reference work in Java 8?

Method references are a shorthand for a lambda expression that calls a method. They come in four types:

Reference to a static method (ClassName::staticMethod).
Reference to an instance method (instance::instanceMethod).
Reference to a constructor (ClassName::new).
Reference to an instance method of an arbitrary object (ClassName::instanceMethod).

15. What are the advantages of using the LocalDate, LocalTime, and LocalDateTime classes over Date and Calendar?

These classes from the java.time package are immutable, thread-safe, and have a more human-readable API. They provide better support for time zones and allow easier formatting and parsing compared to the older Date and Calendar classes.

16. What is the difference between ForkJoinPool and ThreadPoolExecutor?

ForkJoinPool is a special thread pool designed to handle large parallel tasks by recursively dividing them into subtasks (using the Fork/Join framework).

ThreadPoolExecutor is a general-purpose thread pool for managing multiple worker threads.

17. How would you handle a checked exception in a lambda expression?

Since lambda expressions can’t throw checked exceptions directly, you need to wrap the exception inside a runtime exception or use a custom functional interface.

Example using try-catch block:

Stream.of(“file1”, “file2”) .forEach(file -> { try { processFile(file); } catch (IOException e) { throw new UncheckedIOException(e); } });

18. What is the difference between Optional.empty() and Optional.ofNullable()?

Optional.empty() creates an empty Optional object.

Optional.ofNullable() can return either an Optional with the specified value or an empty Optional if the value is null.

19. Explain the difference between Stream’s map() and flatMap() methods.

map() transforms each element of the stream into another object (1-to-1 mapping).

flatMap() flattens the resulting streams of multiple objects into a single stream (1-to-many mapping).

20. How would you refactor a piece of code that has repetitive logic for different types of operations (e.g., add, subtract, multiply) using Java 8?

Use Functional Interfaces like BiFunction to abstract the logic:

BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b; BiFunction<Integer, Integer, Integer> subtract = (a, b) -> a – b; int result = performOperation(5, 3, add); public int performOperation(int a, int b, BiFunction<Integer, Integer, Integer> operation) { return operation.apply(a, b); }

21. What is the role of Spliterator in Java?

Spliterator is a new iterator introduced in Java 8 that is designed for parallelism. It splits the data structure into parts and can be processed in parallel. It also provides characteristics such as SIZED, SUBSIZED, and CONCURRENT.

22. How does the @FunctionalInterface annotation work?

The @FunctionalInterface annotation is used to mark an interface as a functional interface (one that contains exactly one abstract method). It’s a form of documentation and ensures at compile time that the interface adheres to this rule.

23. How can you implement a comparator that handles null values first?

Use Comparator.nullsFirst() to handle null values explicitly:

Comparator<String> comparator = Comparator.nullsFirst(Comparator.naturalOrder()); List<String> list = Arrays.asList(“banana”, null, “apple”); list.sort(comparator); System.out.println(list); // Output: [null, apple, banana]

24. Explain how Optional helps in avoiding NullPointerException.

Optional is a container that can hold a non-null or null value. Instead of returning null, methods can return Optional.empty() or an Optional containing a value. This forces the caller to handle the presence or absence of a value explicitly, avoiding NullPointerException.

25. What is the difference between ForkJoinPool and ExecutorService?

ForkJoinPool is designed for recursive, divide-and-conquer algorithms (splitting tasks into smaller sub-tasks). ExecutorService is more general-purpose, designed for managing a pool of threads for executing concurrent tasks without task splitting.

26. What is the role of StampedLock in Java?

StampedLock is a lock introduced in Java 8 that improves concurrency by allowing optimistic reads and write locks. It provides a way to control read and write access with less contention, making it more performant than traditional read-write locks.

27. What is the use of Collectors.joining() in Java Streams?

Collectors.joining() is used to concatenate elements of a stream into a single String. You can specify a delimiter, a prefix, and a suffix to the resulting String.

28. How do you implement a custom Comparator in Java?

Implement the Comparator interface and override the compare(T o1, T o2) method to define custom sorting logic. You can also use Comparator.comparing() methods for concise and functional-style implementations.

29. How does the ForkJoinPool work internally?

ForkJoinPool splits a large task into smaller subtasks using the ForkJoinTask class. It uses a work-stealing algorithm, where idle threads “steal” tasks from busy threads to balance the workload efficiently.

30. What is the purpose of the AtomicInteger class in Java?

AtomicInteger provides a way to perform atomic operations on integers without using synchronization. It uses low-level atomic primitives like CAS (Compare-And-Swap) to ensure thread safety in concurrent environments.

31. What are the advantages of using lambdas in Java?

Lambdas improve code readability by reducing boilerplate code in anonymous inner classes. They facilitate functional programming and work seamlessly with Java’s Stream API, enabling more expressive data processing.

32. What is the MethodHandles API in Java, and why is it used?

The MethodHandles API (introduced in Java 7) is a low-level, reflection-like API used for dynamically calling methods, accessing fields, and constructing instances. It is more performant and type-safe than reflection.

33. What is the diamond problem in Java, and how does Java 8 solve it?

The diamond problem occurs when a class inherits from multiple interfaces that define the same default method. Java 8 resolves this by requiring the class to override the conflicting method, explicitly choosing which default method to use or providing its own implementation.

34. What is the purpose of the CompletableFuture.supplyAsync() method?

CompletableFuture.supplyAsync() runs a task asynchronously in a separate thread and returns a CompletableFuture that holds the result of the task. It’s commonly used for non-blocking parallel execution.

35. What is a PhantomReference in Java?

PhantomReference is a reference type that allows you to determine exactly when an object has been removed from memory. Unlike WeakReference or SoftReference, it doesn’t provide access to the object and is used for resource cleanup in conjunction with a ReferenceQueue.

36. Explain the concept of immutability. How can you make a class immutable in Java?

An immutable object’s state cannot be changed after its creation. To make a class immutable:

Declare the class as final.
Make all fields private and final.
Provide no setters.
Return deep copies of mutable objects in getter methods.
Initialize all fields in the constructor.

37. What are memory barriers and how are they used in Java concurrency?

Memory barriers are used in multithreading to prevent specific kinds of reordering of instructions by the compiler or processor. In Java, they ensure that changes to variables are visible to other threads. volatile, synchronized, and Lock are examples of constructs that involve memory barriers.

38. Explain the CopyOnWriteArrayList class and when it should be used.

CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (such as add, set, and remove) result in creating a new copy of the underlying array. It’s best used in scenarios where reads are frequent, and writes are rare, as each write operation can be costly due to the array copying process.

39. What is the significance of ReentrantLock in Java concurrency?

ReentrantLock is an explicit lock that provides the same basic behavior as the synchronized keyword but with additional features:

Ability to try acquiring the lock without blocking.
Ability to interrupt while waiting for a lock.
Ability to implement fair locking policies (lock acquisition in the order of requests).
Supports multiple conditions for finer control over lock signaling.

40. What is the role of Predicate, Function, and Supplier in Java 8?

Predicate: Represents a boolean-valued function (accepts one argument and returns a boolean).
Function: Represents a function that accepts one argument and returns a result.
Supplier: Represents a supplier of results (doesn’t accept any arguments and returns a result).

41. What is the difference between countDownLatch and CyclicBarrier in Java?

CountDownLatch allows one or more threads to wait until a set of operations being performed by other threads completes. Once the count reaches zero, all waiting threads are released.

CyclicBarrier allows a set of threads to wait for each other to reach a common barrier point. Once all threads reach the barrier, they are all released, and it can be reused (hence cyclic).

42. Write a program to reverse a LinkedList in Java.

class Node { int data; Node next; Node(int data) { this.data = data; this.next = null; } } public class LinkedList { Node head; public Node reverse(Node head) { Node prev = null; Node current = head; Node next = null; while (current != null) { next = current.next; current.next = prev; prev = current; current = next; } return prev; } }

This iteratively reverses a singly linked list by rearranging the next pointers of the nodes.

43. Write a Java program to find the first non-repeated character in a string.

import java.util.LinkedHashMap; import java.util.Map; public class NonRepeatedCharacter { public static Character firstNonRepeatedChar(String str) { Map<Character, Integer> charCount = new LinkedHashMap<>(); for (char c : str.toCharArray()) { charCount.put(c, charCount.getOrDefault(c, 0) + 1); } for (Map.Entry<Character, Integer> entry : charCount.entrySet()) { if (entry.getValue() == 1) { return entry.getKey(); } } return null; } }

Explanation: This uses a LinkedHashMap to maintain the insertion order and find the first character with a count of 1.

44. Write a Java program to detect a cycle in a linked list.

public class LinkedListCycle { static class Node { int data; Node next; Node(int data) { this.data = data; next = null; } } public static boolean hasCycle(Node head) { if (head == null) return false; Node slow = head; Node fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; if (slow == fast) { return true; } } return false; } }

Explanation: This uses Floyd’s Cycle-Finding Algorithm (Tortoise and Hare) to detect if a cycle exists in a linked list.

45. Write a Java program to implement a custom Comparator for sorting an array of Person objects by age.

import java.util.Arrays; import java.util.Comparator; class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return name + ” (” + age + “)”; } } class AgeComparator implements Comparator<Person> { @Override public int compare(Person p1, Person p2) { return Integer.compare(p1.age, p2.age); } } public class SortByAge { public static void main(String[] args) { Person[] people = { new Person(“Alice”, 30), new Person(“Bob”, 25), new Person(“Charlie”, 35) }; Arrays.sort(people, new AgeComparator()); for (Person p : people) { System.out.println(p); } } }

This sorts an array of Person objects by age using a custom Comparator.

46. Write a Java program to flatten a nested list of integers using Streams.

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class FlattenList { public static void main(String[] args) { List<List<Integer>> nestedList = Arrays.asList( Arrays.asList(1, 2, 3), Arrays.asList(4, 5), Arrays.asList(6, 7, 8) ); List<Integer> flatList = nestedList.stream() .flatMap(List::stream) .collect(Collectors.toList()); System.out.println(flatList); } }

This uses the flatMap() method to flatten a list of lists into a single list.

47. Write a Java program to implement a custom thread pool.

import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class CustomThreadPool { private final BlockingQueue<Runnable> taskQueue; private final Thread[] workers; public CustomThreadPool(int numThreads) { taskQueue = new LinkedBlockingQueue<>(); workers = new Thread[numThreads]; for (int i = 0; i < numThreads; i++) { workers[i] = new Worker(); workers[i].start(); } } public void execute(Runnable task) { taskQueue.offer(task); } private class Worker extends Thread { public void run() { while (true) { try { Runnable task = taskQueue.take(); task.run(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } } } public static void main(String[] args) { CustomThreadPool pool = new CustomThreadPool(3); for (int i = 1; i <= 5; i++) { pool.execute(() -> { System.out.println(Thread.currentThread().getName() + ” is executing task.”); }); } } }

This implements a basic thread pool with a blocking queue of tasks and worker threads that continuously process tasks.

48. Write a Java program to calculate factorial using recursion and memoization.

import java.util.HashMap; import java.util.Map; public class FactorialMemoization { private static Map<Integer, Long> memo = new HashMap<>(); public static long factorial(int n) { if (n == 0 || n == 1) return 1; if (memo.containsKey(n)) return memo.get(n); long result = n * factorial(n – 1); memo.put(n, result); return result; } public static void main(String[] args) { System.out.println(factorial(10)); // Output: 3628800 } }

This calculates the factorial of a number using recursion and memoization to optimize repeated calculations.

49. Write a Java program to find the longest increasing subsequence in an array.

This program computes the longest increasing subsequence (LIS) in an array using dynamic programming.

import java.util.Arrays; public class LongestIncreasingSubsequence { public static int lis(int[] arr) { int n = arr.length; int[] lis = new int[n]; Arrays.fill(lis, 1); for (int i = 1; i < n; i++) { for (int j = 0; j < i; j++) { if (arr[i] > arr[j] && lis[i] < lis[j] + 1) { lis[i] = lis[j] + 1; } } } return Arrays.stream(lis).max().getAsInt(); } public static void main(String[] args) { int[] arr = {10, 22, 9, 33, 21, 50, 41, 60}; System.out.println("Length of LIS: " + lis(arr)); // Output: 5 } }

50. Write a Java program to implement a bounded blocking queue.

import java.util.LinkedList; import java.util.Queue; public class BoundedBlockingQueue { private final Queue<Integer> queue = new LinkedList<>(); private final int capacity; public BoundedBlockingQueue(int capacity) { this.capacity = capacity; } public synchronized void enqueue(int item) throws InterruptedException { while (queue.size() == capacity) { wait(); } queue.offer(item); notifyAll(); } public synchronized int dequeue() throws InterruptedException { while (queue.isEmpty()) { wait(); } int item = queue.poll(); notifyAll(); return item; } }

Related Tags

Java 8 Interview Questions and Answers | Java 8 Training with Placements | Java 8 Interview Questions PDF | Java Interview Questions for Experienced | Java Interview Questions for Freshers

Request more information

Java 8 interview questions with answers for experience upto 8yrs