Core Java Interview Questions & Answers – Part 4 (Intermediate to Advanced)

---

51. What is the Java Collections Framework?

Answer: The Java Collections Framework is a unified architecture for representing and manipulating collections of objects. It provides a set of standard interfaces (like List, Set, Map) and concrete implementations (like ArrayList, HashSet, HashMap) for common data structures.

Why it's important: It provides developers with highly-optimized, reusable data structures and algorithms. Using the framework saves development time, increases performance, and promotes code interoperability.

Use Case:

• List: Use when you need an ordered sequence of items that can contain duplicates. For example, storing the pages of a book in order.
• Set: Use when you need to store a collection of unique items where order is not important. For example, storing the roles assigned to a user (ADMIN, USER).
• Map: Use when you need to store key-value pairs for quick lookups. For example, finding a user object by their unique user ID.

import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.Map;
import java.util.HashMap;

public class CollectionsDemo {
    public static void main(String[] args) {
        // List example
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice"); // Duplicates are allowed
        System.out.println("List of names: " + names);

        // Set example
        Set<String> roles = new HashSet<>();
        roles.add("ADMIN");
        roles.add("USER");
        roles.add("ADMIN"); // Duplicate is ignored
        System.out.println("Set of roles: " + roles);

        // Map example
        Map<String, String> userDetails = new HashMap<>();
        userDetails.put("id", "u123");
        userDetails.put("email", "test@example.com");
        System.out.println("User details map: " + userDetails.get("email"));
    }
}

---

52. What are the differences between ArrayList and LinkedList?

Answer: ArrayList and LinkedList are two of the most common implementations of the List interface, but they have different underlying data structures and performance characteristics.

• ArrayList: Is backed by a dynamic array. It provides fast random access to elements (e.g., get(index)) because it can calculate the memory address of an element directly. However, adding or removing elements from the middle of the list is slow because it requires shifting subsequent elements.
• LinkedList: Is backed by a doubly-linked list. Each element (node) holds a reference to the previous and next element. Random access is slow because it must traverse the list from the beginning or end. However, adding or removing elements is fast because it only involves updating the links of the neighboring nodes.

When to use which:

• Use ArrayList for read-heavy operations where you need frequent access to elements by their index. This is the most common default choice.
• Use LinkedList for write-heavy operations where you have frequent insertions and deletions, especially in the middle of the list.

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListPerformanceDemo {
    public static void main(String[] args) {
        // ArrayList: Fast for getting elements
        List<String> arrayList = new ArrayList<>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        System.out.println("ArrayList get(1): " + arrayList.get(1)); // Very fast

        // LinkedList: Faster for adding/removing from the middle
        List<String> linkedList = new LinkedList<>();
        linkedList.add("A");
        linkedList.add("B");
        linkedList.add("C");
        linkedList.add(1, "X"); // Faster than ArrayList for large lists
        System.out.println("LinkedList after adding 'X' at index 1: " + linkedList);
    }
}

---

53. Compare HashMap and Hashtable.

Answer: HashMap and Hashtable both store key-value pairs, but they have critical differences:

Feature	HashMap	Hashtable
Synchronization	Non-synchronized (not thread-safe).	Synchronized (thread-safe).
Null Values	Allows one null key and multiple null values.	Does not allow null keys or null values.
Performance	Faster, as it is not burdened by synchronization.	Slower due to the overhead of synchronization.
Legacy	Introduced in JDK 1.2 as part of Collections.	A legacy class from JDK 1.0.

Which one to use? You should almost always use HashMap in modern, single-threaded applications. If you need a thread-safe map, the modern and much more performant choice is ConcurrentHashMap, not Hashtable.

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class MapComparison {
    public static void main(String[] args) {
        // HashMap allows null key and values
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("key1", "value1");
        hashMap.put(null, "some value");
        hashMap.put("key2", null);
        System.out.println("HashMap: " + hashMap);

        // Hashtable does not allow nulls
        Map<String, String> hashtable = new Hashtable<>();
        try {
            hashtable.put("key1", "value1");
            hashtable.put(null, "some value"); // This will throw NullPointerException
        } catch (NullPointerException e) {
            System.err.println("Error with Hashtable: " + e.getMessage());
        }
        System.out.println("Hashtable: " + hashtable);
    }
}

---

54. Explain final, finally, and finalize.

Answer: These three are unrelated concepts in Java that sound similar but have completely different purposes.

• final (Keyword): A modifier that can be applied to variables, methods, and classes.
  • Variable: Makes its value unchangeable (a constant).
  • Method: Prevents the method from being overridden by subclasses.
  • Class: Prevents the class from being extended (inherited).
• finally (Block): A block used in a try-catch statement. The finally block always executes, regardless of whether an exception is thrown or caught. It's used for cleanup code, like closing files or database connections.
• finalize (Method): A method from the Object class that the Garbage Collector (GC) calls on an object just before reclaiming its memory. Its use is strongly discouraged as it's not guaranteed to run, and better alternatives like try-with-resources exist for cleanup.

Use Case:

• final: Defining a mathematical constant like public static final double PI = 3.14159;.
• finally: Ensuring a network socket is closed even if a connection error occurs.
• finalize: (For demonstration only) Logging a message when an object is garbage collected.

// 1. final keyword
final class Constants {
    public static final String APP_NAME = "MyApp";
    public final void display() { System.out.println(APP_NAME); }
}

// 2. finally block
public class FinallyDemo {
    public void processFile() {
        // Assuming 'file' is a resource
        try {
            System.out.println("Opening and processing file...");
            // int error = 1 / 0; // Uncomment to simulate an exception
        } catch (Exception e) {
            System.err.println("An error occurred: " + e.getMessage());
        } finally {
            System.out.println("Closing file resource. This always runs.");
        }
    }
}

// 3. finalize method (discouraged)
class FinalizeDemo {
    @Override
    protected void finalize() throws Throwable {
        // This is not a reliable cleanup mechanism.
        System.out.println("Finalize method called. Object is being garbage collected.");
    }
}

---

55. What is the Java Stream API?

Answer: Introduced in Java 8, the Stream API is a way to process sequences of elements in a functional style. A stream is not a data structure; instead, it takes input from a source (like a Collection), performs aggregate operations on it in a pipeline, and returns a result.

Why it's important:

• Declarative & Readable: You describe what you want to do, not how to do it, making code more concise than traditional loops.
• Parallelism: Streams can be easily parallelized to leverage multi-core processors for better performance.
• Lazy Evaluation: Intermediate operations are only performed when a terminal operation is initiated, which can lead to performance optimizations.

Use Case: Imagine you have a list of products. You want to find all electronics products costing more than $500, get their names, and store them in a new list.

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

class Product {
    String name;
    String category;
    double price;
    // constructor, getters...
    public Product(String name, String category, double price) {
        this.name = name; this.category = category; this.price = price;
    }
    public String getName() { return name; }
    public String getCategory() { return category; }
    public double getPrice() { return price; }
}

public class StreamDemo {
    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product("Laptop", "Electronics", 1200));
        products.add(new Product("Shirt", "Apparel", 50));
        products.add(new Product("Smartphone", "Electronics", 800));
        products.add(new Product("Book", "Literature", 20));

        // Using Stream API to filter and map
        List<String> expensiveElectronicsNames = products.stream() // 1. Create a stream
            .filter(p -> "Electronics".equals(p.getCategory()))   // 2. Filter electronics
            .filter(p -> p.getPrice() > 500)                      // 3. Filter by price
            .map(Product::getName)                                // 4. Get their names
            .collect(Collectors.toList());                        // 5. Collect into a new list

        System.out.println(expensiveElectronicsNames); // Outputs: [Laptop, Smartphone]
    }
}

---

56. What is the Optional class in Java?

Answer: Optional is a container object introduced in Java 8 that may or may not contain a non-null value. It is designed to provide a better, more explicit way to handle cases where a value might be absent, rather than returning null and risking a NullPointerException.

Why it's important: It forces the developer to actively think about and handle the "value not present" case. This helps create more robust and bug-free code by making potential null values a part of the type system.

Use Case: A method that searches for a user in a database might not find one for a given ID. Instead of returning null, it can return an Optional<User>.

import java.util.Optional;

class User {
    private final String id;
    public User(String id) { this.id = id; }
    public String getId() { return id; }
}

public class OptionalDemo {
    // This method simulates finding a user in a database
    public static Optional<User> findUserById(String id) {
        if ("u123".equals(id)) {
            return Optional.of(new User(id)); // Value is present
        }
        return Optional.empty(); // Value is absent
    }

    public static void main(String[] args) {
        // Handling the "present" case
        findUserById("u123").ifPresent(user -> {
            System.out.println("User found: " + user.getId());
        });

        // Handling the "absent" case with a default value
        User user = findUserById("u404").orElse(new User("guest"));
        System.out.println("Current user: " + user.getId()); // Outputs: Current user: guest

        // Throwing an exception if the value is not present
        try {
            User foundUser = findUserById("u404").orElseThrow(() -> new Exception("User not found"));
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}

---

57. What are Lambda Expressions?

Answer: A lambda expression is an anonymous function (a function without a name) that can be treated as a first-class value. It provides a clear and concise way to represent one method interface using an expression. Lambdas are a key feature of functional programming in Java.

The basic syntax is: (parameters) -> expression or (parameters) -> { statements; }

Why they are important: They allow you to pass behavior (code) as an argument to methods, leading to more flexible and powerful APIs. They significantly reduce boilerplate code, especially for event listeners, comparators, and operations on collections (like with the Stream API).

Use Case: Sorting a list of strings based on their length without having to write a full anonymous inner class for the Comparator.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class LambdaDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("David");
        names.add("Bob");

        // Pre-Java 8 way with an anonymous inner class
        // Collections.sort(names, new Comparator<String>() {
        //     @Override
        //     public int compare(String a, String b) {
        //         return a.compareTo(b);
        //     }
        // });

        // With a Lambda Expression (more concise)
        Collections.sort(names, (a, b) -> a.compareTo(b));
        System.out.println("Sorted names: " + names);

        // Another example: iterating with forEach
        names.forEach(name -> System.out.println("Hello, " + name));
    }
}

---

58. Explain the synchronized keyword.

Answer: The synchronized keyword is Java's built-in mechanism for enforcing thread safety. It ensures that only one thread at a time can execute a block of code or a method that is protected by the same monitor (lock).

When a thread enters a synchronized method or block, it acquires an intrinsic lock. Any other thread that tries to enter a synchronized block protected by the same lock will be blocked until the lock is released.

Why it's important: It is the fundamental tool for preventing race conditions and ensuring data consistency when multiple threads are accessing and modifying shared, mutable state.

Use Case: A simple counter that is accessed by multiple threads. Without synchronization, increment operations (count++) are not atomic and can lead to lost updates.

class Counter {
    private int count = 0;

    // This method is thread-safe
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedDemo {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // Create two threads that increment the counter
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        t1.join(); // Wait for t1 to finish
        t2.join(); // Wait for t2 to finish

        // Without synchronization, the result would likely be less than 2000
        System.out.println("Final count: " + counter.getCount());
    }
}

---

59. What is the volatile keyword?

Answer: The volatile keyword is a field modifier used to indicate that a variable's value will be modified by different threads. It ensures visibility—meaning that any write to a volatile variable is immediately flushed to main memory, and any read of that variable will be directly from main memory.

However, volatile does not guarantee atomicity. For compound operations like count++ (read-modify-write), you still need synchronization.

Why it's important: It's a lightweight synchronization mechanism that is less expensive than a full synchronized block. It's perfect for ensuring the visibility of simple flags or status variables shared between threads.

Use Case: A common use is a boolean flag that controls the execution of a thread. The main thread can change the flag, and the worker thread is guaranteed to see the change and stop its work gracefully.

class Worker implements Runnable {
    // The volatile keyword ensures the 'running' flag is visible across threads
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            System.out.println("Worker thread is running...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("Worker thread has stopped.");
    }
}

public class VolatileDemo {
    public static void main(String[] args) throws InterruptedException {
        Worker worker = new Worker();
        Thread workerThread = new Thread(worker);
        workerThread.start();

        // Let the worker run for 3 seconds
        Thread.sleep(3000);

        // Signal the worker to stop
        System.out.println("Main thread signaling worker to stop...");
        worker.stop();
    }
}

---

60. What is an ExecutorService?

Answer: An ExecutorService is a high-level framework from Java's Concurrency API for managing and executing asynchronous tasks. It abstracts away the details of manual thread creation and management by using a thread pool. You submit tasks (Runnable or Callable) to the service, and it handles their execution on available threads.

Why it's important:

• Improved Performance: It reuses existing threads, avoiding the overhead of creating new ones for each task.
• Resource Management: It provides better control over system resources by limiting the number of active threads.
• Decoupling: It separates task submission from the execution policy, making your code cleaner and more flexible.
• Lifecycle Management: It provides methods to gracefully shut down the threads.

Use Case: A web server processing incoming requests. Instead of creating a new thread for every request (which is inefficient), requests are submitted as tasks to a fixed-size thread pool managed by an ExecutorService.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ExecutorServiceDemo {
    public static void main(String[] args) {
        // Create a thread pool with 2 threads
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Submit 5 tasks for execution
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            Runnable task = () -> {
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // Simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            };
            executor.submit(task);
        }

        // It's crucial to shut down the executor service
        executor.shutdown(); // Initiates a graceful shutdown
        try {
            // Wait for all tasks to complete
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // Force shutdown if tasks don't finish
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }

        System.out.println("All tasks submitted.");
    }
}