Java Interview Questions for Experienced Professionals

Preparation for Advanced Java Interviews

Landing a job as an experienced Java developer requires thorough preparation. With five years of experience, interviewers expect in-depth knowledge of advanced Java concepts, problem-solving skills, and familiarity with frameworks like Spring and Hibernate. A well-structured approach to preparation can help candidates confidently tackle challenging interview questions.

Most companies focus on core Java principles, object-oriented programming (OOP), multithreading, memory management, and best practices. They also assess a candidate’s ability to optimize code, work with databases, and debug complex applications. To stand out, candidates must demonstrate practical knowledge and experience with Java frameworks and real-world problem-solving techniques.

Table of Contents

Understanding Core and Advanced Java Concepts

Mastering Java requires a strong foundation in both core and advanced topics. Here are key concepts to focus on:

• OOP Principles: Encapsulation, inheritance, polymorphism, and abstraction.
• Multithreading & Concurrency: Synchronization, deadlocks, thread pools, and parallel processing.
• Collections Framework: Lists, sets, maps, and their internal implementations.
• Exception Handling: Checked vs. unchecked exceptions, custom exceptions, and best practices.
• JVM Internals: Garbage collection, memory management, and class loading mechanisms.
• Java I/O and NIO: File handling, serialization, and deserialization.
• Lambda Expressions & Streams API: Functional programming features introduced in Java 8.

A deep understanding of these concepts will help candidates effectively answer technical interview questions.

OOP Principles (Encapsulation, Inheritance, Polymorphism, and Abstraction)

1. What are the four main principles of OOP?

Answer:
The four main principles of OOP are:

• Encapsulation: Bundling data and methods that operate on it, restricting direct access (using access modifiers like private).
• Inheritance: Allows a class to inherit properties and behaviors from another class using the extends keyword.
• Polymorphism: Enables one interface to be used for multiple implementations (method overriding and overloading).
• Abstraction: Hides complex implementation details and exposes only essential features (using abstract classes or interfaces).
  These principles promote modularity, reusability, and flexibility in code design.

2. What is encapsulation, and how is it achieved in Java?

Answer:
Encapsulation is the process of hiding internal details of an object and providing controlled access via public methods (getters/setters). It ensures data integrity and security.
How Achieved:

• Use private fields.
• Provide public getter and setter methods.
  Example:

public class Employee {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) this.age = age; // Validation
    }
}

3. What is inheritance, and why is it useful?

Answer:
Inheritance allows a class (subclass) to inherit fields and methods from another class (superclass) using the extends keyword. It promotes code reuse and establishes a “is-a” relationship.
Benefits:

• Reduces redundancy.
• Supports hierarchical classification.
  Example:

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Inherited method
        dog.bark(); // Subclass method
    }
}

4. What is the difference between super and this keywords?

Answer:

• this: Refers to the current instance of the class. Used to differentiate instance variables from parameters or to call another constructor in the same class.
• super: Refers to the superclass. Used to call superclass methods, constructors, or access superclass fields.
  Example:

class Parent {
    String name = "Parent";
}

class Child extends Parent {
    String name = "Child";

    void display() {
        System.out.println(this.name);      // Child
        System.out.println(super.name);     // Parent
    }
}

public class Test {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
    }
}

5. What is polymorphism, and what are its types in Java?

Answer:
Polymorphism allows objects to be treated as instances of their parent class or interface, enabling flexibility.
Types:

• Compile-time (Static) Polymorphism: Achieved via method overloading.
• Runtime (Dynamic) Polymorphism: Achieved via method overriding.
  Example (Overloading):

class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
}

Example (Overriding):

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Meow");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myCat = new Cat();
        myCat.sound(); // Meow (runtime polymorphism)
    }
}

6. What is method overloading, and how does it work?

Answer:
Method overloading allows multiple methods with the same name but different parameter lists (number, type, or order). It’s resolved at compile time.
Rules:

• Method name must be the same.
• Parameters must differ.
• Return type alone isn’t enough to overload.
  Example:

class MathUtils {
    int multiply(int a, int b) {
        return a * b;
    }
    double multiply(double a, double b) {
        return a * b;
    }
}

public class Test {
    public static void main(String[] args) {
        MathUtils math = new MathUtils();
        System.out.println(math.multiply(2, 3));     // 6
        System.out.println(math.multiply(2.5, 3.5)); // 8.75
    }
}

7. What is method overriding, and what are its rules?

Answer:
Method overriding occurs when a subclass provides a specific implementation of a method defined in its superclass. It’s resolved at runtime.
Rules:

• Method name, return type, and parameters must match.
• Access modifier cannot be more restrictive.
• Must be inherited (not private).
  Example:

class Parent {
    void show() {
        System.out.println("Parent's show");
    }
}

class Child extends Parent {
    void show() {
        System.out.println("Child's show");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show(); // Child's show
    }
}

8. What is abstraction, and how is it implemented in Java?

Answer:
Abstraction hides implementation details and shows only the essential features. It’s achieved using:

• Abstract Classes: Cannot be instantiated, may contain abstract and concrete methods.
• Interfaces: Fully abstract, define a contract.
  Example (Abstract Class):

abstract class Shape {
    abstract double area(); // Abstract method
    void display() {        // Concrete method
        System.out.println("This is a shape.");
    }
}

class Circle extends Shape {
    double radius;
    Circle(double radius) {
        this.radius = radius;
    }
    double area() {
        return Math.PI * radius * radius;
    }
}

public class Test {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        System.out.println(circle.area()); // 78.54
    }
}

9. What is the difference between an abstract class and an interface?

Answer:

• Abstract Class: Can have abstract and non-abstract methods, fields, and constructors. Supports single inheritance.
• Interface: Only abstract methods (until Java 8, which added default and static methods), no fields or constructors. Supports multiple inheritance.
  Example:

interface Flyable {
    void fly();
}

abstract class Bird {
    abstract void eat();
}

class Sparrow extends Bird implements Flyable {
    void eat() {
        System.out.println("Sparrow eats seeds.");
    }
    public void fly() {
        System.out.println("Sparrow flies.");
    }
}

10. What is the final keyword in Java?

Answer:
The final keyword restricts modification:

• Class: Cannot be inherited (final class MyClass).
• Method: Cannot be overridden.
• Variable: Becomes a constant (cannot be reassigned).
  Example:

final class Immutable {
    final int value = 10;
    final void show() {
        System.out.println(value);
    }
}

public class Test {
    public static void main(String[] args) {
        Immutable obj = new Immutable();
        obj.show(); // 10
    }
}

11. Can a class inherit multiple classes in Java?

Answer:
No, Java doesn’t support multiple inheritance of classes to avoid the “diamond problem.” However, a class can implement multiple interfaces.
Example:

interface A {
    void methodA();
}

interface B {
    void methodB();
}

class MyClass implements A, B {
    public void methodA() {
        System.out.println("Method A");
    }
    public void methodB() {
        System.out.println("Method B");
    }
}

12. What is the role of access modifiers in encapsulation?

Answer:
Access modifiers (public, private, protected, default) control the visibility of class members, enforcing encapsulation:

• private: Only accessible within the class.
• public: Accessible everywhere.
• protected: Accessible within the package and subclasses.
• default (no modifier): Package-private.
  Example:

class Encapsulated {
    private int secret = 42;
    public int getSecret() {
        return secret;
    }
}

13. What is runtime polymorphism, and how is it achieved?

Answer:
Runtime polymorphism (dynamic method dispatch) occurs when a subclass overrides a superclass method, and the method call is resolved at runtime based on the object’s actual type.
How Achieved: Through method overriding and upcasting.
Example:

class Vehicle {
    void move() {
        System.out.println("Vehicle moves");
    }
}

class Car extends Vehicle {
    void move() {
        System.out.println("Car moves fast");
    }
}

public class Test {
    public static void main(String[] args) {
        Vehicle v = new Car(); // Upcasting
        v.move();             // Car moves fast
    }
}

14. What is the diamond problem, and how does Java avoid it?

Answer:
The diamond problem occurs in multiple inheritance when a class inherits from two classes that have a common ancestor, leading to ambiguity. Java avoids this by disallowing multiple class inheritance. Interfaces mitigate this with default methods (since Java 8), requiring explicit resolution if conflicts arise.
Example:

interface A {
    default void show() {
        System.out.println("A");
    }
}

interface B {
    default void show() {
        System.out.println("B");
    }
}

class C implements A, B {
    public void show() {
        A.super.show(); // Explicitly resolve conflict
    }
}

15. What is the instanceof operator, and how is it used with polymorphism?

Answer:
The instanceof operator checks if an object is an instance of a specific class or interface. It’s useful in polymorphism to safely downcast objects.
Example:

class Animal {}
class Dog extends Animal {}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // Safe downcasting
            System.out.println("It's a dog!");
        }
    }
}

16. Can constructors be inherited or overridden?

Answer:

• Inherited: No, constructors are not inherited because they are not members of a class; they initialize objects.
• Overridden: No, constructors cannot be overridden since they are not methods and have the same name as the class. However, you can call a superclass constructor using super().
  Example:

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // Calls Parent constructor
        System.out.println("Child constructor");
    }
}

17. What is the difference between composition and inheritance?

Answer:

• Inheritance: “Is-a” relationship (e.g., Dog is an Animal). Subclass inherits superclass behavior.
• Composition: “Has-a” relationship (e.g., Car has an Engine). Objects are composed of other objects.
  Example (Composition):

class Engine {
    void start() {
        System.out.println("Engine started");
    }
}

class Car {
    Engine engine = new Engine();
    void drive() {
        engine.start();
        System.out.println("Car driving");
    }
}

18. What is an interface, and how does it support abstraction?

Answer:
An interface is a fully abstract type that defines a contract of methods without implementations (until Java 8’s default methods). It supports abstraction by allowing classes to implement it, hiding implementation details.
Example:

interface Printable {
    void print();
}

class Document implements Printable {
    public void print() {
        System.out.println("Printing document");
    }
}

19. What is the purpose of the @Override annotation?

Answer:
The @Override annotation indicates that a method overrides a superclass or interface method. It ensures compile-time checking to avoid errors (e.g., typos in method names).
Example:

class Parent {
    void display() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child");
    }
}

20. How does Java handle multiple inheritance with interfaces?

Answer:
Java allows a class to implement multiple interfaces, avoiding the diamond problem of multiple class inheritance. If two interfaces have conflicting default methods, the implementing class must explicitly override and resolve the conflict.
Example:

interface X {
    default void show() {
        System.out.println("X");
    }
}

interface Y {
    default void show() {
        System.out.println("Y");
    }
}

class Z implements X, Y {
    public void show() {
        X.super.show(); // Resolving conflict
        Y.super.show();
    }
}

public class Test {
    public static void main(String[] args) {
        Z z = new Z();
        z.show(); // X then Y
    }
}

Multithreading & Concurrency

1. What is multithreading in Java, and why is it used?

Answer:
Multithreading is the ability of a program to execute multiple threads concurrently within a single process. Each thread represents an independent flow of execution. It’s used to improve performance by utilizing CPU resources efficiently, handling tasks like I/O operations, and enabling responsive applications.
Example:

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // Starts the thread
    }
}

2. What are the two ways to create a thread in Java?

Answer:

• Extending Thread class: Override the run() method.
• Implementing Runnable interface: Implement run() and pass it to a Thread object.
  Example (Extending Thread):

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread via Thread class");
    }
}

Example (Implementing Runnable):

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread via Runnable");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

3. What is the difference between Thread and Runnable?

Answer:

• Thread: A class that directly supports threading. You extend it and override run().
• Runnable: An interface with a single run() method. Preferred because it allows the class to extend another class (Java doesn’t support multiple inheritance).
  Key Point: Use Runnable for flexibility and better design.

4. What is the purpose of the start() and run() methods?

Answer:

• run(): Contains the code to be executed by the thread. Calling it directly runs the code in the current thread.
• start(): Initiates a new thread and invokes run() in that separate thread.
  Example:

class MyThread extends Thread {
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.run();   // Runs in main thread
        t.start(); // Runs in new thread
    }
}

5. What is thread synchronization, and why is it needed?

Answer:
Synchronization ensures that only one thread can access a shared resource at a time, preventing race conditions (inconsistent data due to concurrent access). It’s needed in multithreaded programs to maintain data integrity.
Example:

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new 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(); t2.join();
        System.out.println(counter.getCount()); // 2000 (consistent with synchronization)
    }
}

6. What is the synchronized keyword, and how does it work?

Answer:
The synchronized keyword ensures thread-safe access by locking an object or method. Only one thread can hold the lock at a time.

• Synchronized Method: Locks the object instance.
• Synchronized Block: Locks a specific object.
  Example (Block):

class Shared {
    void print(int n) {
        synchronized (this) {
            for (int i = 1; i <= 5; i++) {
                System.out.println(n * i);
            }
        }
    }
}

7. What is a deadlock, and how can it be avoided?

Answer:
A deadlock occurs when two or more threads are blocked forever, each waiting for a resource the other holds.
Conditions: Mutual exclusion, hold and wait, no preemption, circular wait.
Avoidance:

• Avoid nested locks.
• Use timeouts.
• Order resource acquisition.
  Example:

public class DeadlockDemo {
    public static void main(String[] args) {
        String r1 = "Resource1";
        String r2 = "Resource2";

        Thread t1 = new Thread(() -> {
            synchronized (r1) {
                System.out.println("T1 locked r1");
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (r2) {
                    System.out.println("T1 locked r2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (r2) {
                System.out.println("T2 locked r2");
                try { Thread.sleep(100); } catch (Exception e) {}
                synchronized (r1) {
                    System.out.println("T2 locked r1");
                }
            }
        });

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

8. What is the difference between wait() and sleep()?

Answer:

• wait(): Releases the monitor (lock) and waits for notify() or notifyAll(). Used with synchronization.
• sleep(): Pauses the current thread for a specified time without releasing locks.
  Example:

class WaitDemo {
    synchronized void demo() throws InterruptedException {
        System.out.println("Before wait");
        wait(1000); // Releases lock
        System.out.println("After wait");
    }
}

9. What are notify() and notifyAll() methods?

Answer:

• notify(): Wakes up one waiting thread (randomly chosen).
• notifyAll(): Wakes up all waiting threads; they compete for the lock.
  Both are used with wait() in synchronized blocks.
  Example:

class Shared {
    synchronized void waitForSignal() throws InterruptedException {
        wait();
        System.out.println("Received signal");
    }

    synchronized void sendSignal() {
        notify();
    }
}

10. What is a thread pool, and how is it implemented in Java?

Answer:
A thread pool manages a pool of reusable threads to execute tasks, reducing overhead of thread creation. Java provides ExecutorService for this.
Example:

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

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> System.out.println("Task by " + Thread.currentThread().getName()));
        }
        executor.shutdown();
    }
}

11. What is the ExecutorService interface?

Answer:
ExecutorService is a higher-level replacement for managing threads. It provides methods like submit(), shutdown(), and supports thread pools. It abstracts thread creation and lifecycle management.
Key Point: Use Executors factory methods to create instances.

12. What is the volatile keyword, and when is it used?

Answer:
The volatile keyword ensures a variable’s value is always read from and written to main memory, preventing thread caching issues. It’s used for variables accessed by multiple threads without synchronization.
Example:

class VolatileDemo {
    volatile boolean flag = true;

    void run() {
        while (flag) {
            System.out.println("Running...");
        }
    }
}

13. What is the ThreadLocal class, and how does it work?

Answer:
ThreadLocal provides thread-local variables, where each thread has its own copy. It’s useful for maintaining thread-specific data (e.g., user sessions).
Example:

public class ThreadLocalDemo {
    static ThreadLocal<Integer> local = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            local.set(100);
            System.out.println("T1: " + local.get());
        });
        Thread t2 = new Thread(() -> System.out.println("T2: " + local.get()));
        t1.start(); t2.start();
    }
}

14. What is the difference between ReentrantLock and synchronized?

Answer:

• synchronized: Implicit locking, simpler but less flexible.
• ReentrantLock: Explicit locking (from java.util.concurrent.locks), offers features like fairness, timeouts, and condition variables.
  Example (ReentrantLock):

import java.util.concurrent.locks.ReentrantLock;

class LockDemo {
    ReentrantLock lock = new ReentrantLock();

    void process() {
        lock.lock();
        try {
            System.out.println("Processing...");
        } finally {
            lock.unlock();
        }
    }
}

15. What is a Semaphore, and how is it used?

Answer:
A Semaphore controls access to a shared resource by maintaining a set of permits. Threads acquire permits to proceed and release them when done.
Example:

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " acquired");
                Thread.sleep(1000);
            } catch (InterruptedException e) {}
            finally {
                semaphore.release();
            }
        };
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
    }
}

16. What is the CountDownLatch class?

Answer:
CountDownLatch allows one or more threads to wait until a set of operations (count) completes. It’s useful for coordinating thread execution.
Example:

import java.util.concurrent.CountDownLatch;

public class LatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        Runnable task = () -> {
            System.out.println("Task done");
            latch.countDown();
        };
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        latch.await(); // Waits until count reaches 0
        System.out.println("All tasks completed");
    }
}

17. What is a race condition, and how can it be prevented?

Answer:
A race condition occurs when multiple threads access shared data concurrently, leading to unpredictable results. It’s prevented using synchronization mechanisms like synchronized, Lock, or atomic classes.
Example: See synchronization example in Q5.

18. What is the Future interface, and how does it work with Callable?

Answer:
Future represents the result of an asynchronous computation. Callable is like Runnable but returns a value and can throw exceptions. Future retrieves the result via get().
Example:

import java.util.concurrent.*;

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 42;
        };
        Future<Integer> future = executor.submit(task);
        System.out.println("Result: " + future.get()); // Blocks until result
        executor.shutdown();
    }
}

19. What is the ForkJoinPool and how does it support parallel processing?

Answer:
ForkJoinPool is a thread pool for parallel processing, optimized for divide-and-conquer tasks (e.g., recursive algorithms). It uses work-stealing to balance load.
Example:

import java.util.concurrent.*;

public class ForkJoinDemo extends RecursiveTask<Integer> {
    int[] array;
    int start, end;

    ForkJoinDemo(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 2) {
            int sum = 0;
            for (int i = start; i < end; i++) sum += array[i];
            return sum;
        }
        int mid = (start + end) / 2;
        ForkJoinDemo left = new ForkJoinDemo(array, start, mid);
        ForkJoinDemo right = new ForkJoinDemo(array, mid, end);
        left.fork();
        return right.compute() + left.join();
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        ForkJoinPool pool = new ForkJoinPool();
        System.out.println(pool.invoke(new ForkJoinDemo(array, 0, array.length))); // 10
    }
}

20. What are atomic classes, and how do they help in concurrency?

Answer:
Atomic classes (e.g., AtomicInteger, AtomicReference) provide thread-safe operations without locks, using Compare-And-Swap (CAS). They’re efficient for simple operations like incrementing.
Example:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicDemo {
    static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> { for (int i = 0; i < 1000; i++) counter.incrementAndGet(); };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(counter.get()); // 2000
    }
}

Collections Framework

1. What is the Java Collections Framework?

Answer:
The Java Collections Framework is a set of interfaces and classes in the java.util package that provides a standardized way to store, manipulate, and access groups of objects. It includes data structures like lists, sets, and maps, along with algorithms for sorting, searching, and more. Key interfaces are Collection, List, Set, and Map.

2. What is the difference between Collection and Collections?

Answer:

• Collection: An interface that defines the basic structure for collections (e.g., List, Set).
• Collections: A utility class with static methods for manipulating collections (e.g., Collections.sort(), Collections.synchronizedList()).
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));
        Collections.sort(list); // Uses Collections class
        System.out.println(list); // [1, 2, 3]
    }
}

3. What are the main differences between List, Set, and Map?

Answer:

• List: Ordered, allows duplicates (e.g., ArrayList, LinkedList).
• Set: Unordered, no duplicates (e.g., HashSet, TreeSet).
• Map: Key-value pairs, unique keys (e.g., HashMap, TreeMap).
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "A"));
        Set<String> set = new HashSet<>(Arrays.asList("A", "A"));
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "A"); map.put(1, "B");
        System.out.println(list); // [A, A]
        System.out.println(set);  // [A]
        System.out.println(map);  // {1=B}
    }
}

4. What is the difference between ArrayList and LinkedList?

Answer:

• ArrayList: Backed by a dynamic array, fast for random access (get()), slower for insertions/deletions.
• LinkedList: Doubly-linked list, fast for insertions/deletions, slower for random access.
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();
        arrayList.add(1); linkedList.add(1);
        System.out.println(arrayList.get(0)); // Fast
        linkedList.add(0, 2); // Faster than ArrayList
    }
}

5. How does HashMap work internally?

Answer:
HashMap uses a hash table with an array of buckets. Keys are hashed using hashCode(), and the index is computed (index = hash & (length-1)). Collisions are resolved with linked lists (or red-black trees in Java 8+ if bucket size exceeds a threshold).
Key Operations:

• put(): O(1) average, O(n) worst case.
• get(): O(1) average.
  Example:

import java.util.HashMap;
public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        System.out.println(map.get("A")); // 1
    }
}

6. What is the difference between HashMap and Hashtable?

Answer:

• HashMap: Not synchronized, allows null keys/values, faster.
• Hashtable: Synchronized, no nulls allowed, thread-safe but slower.
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        HashMap<String, String> hm = new HashMap<>();
        hm.put(null, "Value"); // Allowed
        Hashtable<String, String> ht = new Hashtable<>();
        // ht.put(null, "Value"); // NullPointerException
    }
}

7. What is the significance of equals() and hashCode() in collections?

Answer:
Collections like HashMap and HashSet use hashCode() to determine the bucket and equals() to check for equality within the bucket. They must be overridden consistently for custom objects.
Example:

class Person {
    String name;
    Person(String name) { this.name = name; }
    @Override
    public int hashCode() { return name.hashCode(); }
    @Override
    public boolean equals(Object obj) {
        return obj instanceof Person && ((Person) obj).name.equals(this.name);
    }
}

import java.util.HashSet;
public class Test {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        set.add(new Person("Alice"));
        set.add(new Person("Alice"));
        System.out.println(set.size()); // 1
    }
}

8. What is the difference between HashSet and TreeSet?

Answer:

• HashSet: Backed by HashMap, unordered, O(1) for add/remove/contains, allows null.
• TreeSet: Backed by a red-black tree, sorted, O(log n) operations, no nulls.
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Set<String> hashSet = new HashSet<>(Arrays.asList("C", "A", "B"));
        Set<String> treeSet = new TreeSet<>(Arrays.asList("C", "A", "B"));
        System.out.println(hashSet); // [A, B, C] (unordered)
        System.out.println(treeSet); // [A, B, C] (sorted)
    }
}

9. What is the Comparable interface, and how is it used?

Answer:
Comparable defines natural ordering for objects via the compareTo() method. It’s used by TreeSet, TreeMap, and Collections.sort().
Example:

class Student implements Comparable<Student> {
    int id;
    Student(int id) { this.id = id; }
    @Override
    public int compareTo(Student o) { return this.id - o.id; }
}

import java.util.TreeSet;
public class Test {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>();
        set.add(new Student(3));
        set.add(new Student(1));
        System.out.println(set); // [1, 3]
    }
}

10. What is the Comparator interface, and how does it differ from Comparable?

Answer:
Comparator provides custom ordering via compare(). Unlike Comparable (natural ordering inside the class), Comparator is external and flexible.
Example:

import java.util.*;
class Student {
    int id;
    Student(int id) { this.id = id; }
    @Override
    public String toString() { return String.valueOf(id); }
}

public class Test {
    public static void main(String[] args) {
        Comparator<Student> byId = (s1, s2) -> s2.id - s1.id; // Reverse order
        TreeSet<Student> set = new TreeSet<>(byId);
        set.add(new Student(3));
        set.add(new Student(1));
        System.out.println(set); // [3, 1]
    }
}

11. How does ConcurrentHashMap differ from HashMap?

Answer:

• HashMap: Not thread-safe, faster for single-threaded use.
• ConcurrentHashMap: Thread-safe, allows concurrent reads and segmented writes, better for multithreaded applications.
  Example:

import java.util.concurrent.ConcurrentHashMap;
public class Test {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("A", 1);
        System.out.println(map.get("A")); // 1
    }
}

12. What is the internal implementation of ArrayList?

Answer:
ArrayList uses a dynamic array that grows by 50% when full (new capacity = old * 1.5). It provides O(1) access but O(n) for insertions/deletions due to shifting elements.
Key Point: Initial capacity is 10 by default.

13. What is the LinkedHashMap, and how does it maintain order?

Answer:
LinkedHashMap extends HashMap and maintains insertion order (or access order if specified) using a doubly-linked list across entries.
Example:

import java.util.LinkedHashMap;
public class Test {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        map.put("C", 3);
        map.put("A", 1);
        System.out.println(map.keySet()); // [C, A]
    }
}

14. What is the difference between Iterator and ListIterator?

Answer:

• Iterator: Traverses any Collection, forward-only, supports remove().
• ListIterator: Specific to List, bidirectional, supports add(), set(), remove().
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B"));
        ListIterator<String> it = list.listIterator();
        it.next(); // A
        it.set("X"); // Replace A with X
        System.out.println(list); // [X, B]
    }
}

15. What is the PriorityQueue, and how does it work?

Answer:
PriorityQueue is a queue where elements are ordered by natural ordering or a Comparator. It uses a binary heap internally, offering O(log n) for add/remove.
Example:

import java.util.PriorityQueue;
public class Test {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.offer(3);
        pq.offer(1);
        System.out.println(pq.poll()); // 1 (smallest first)
    }
}

16. What is the fail-fast behavior of iterators?

Answer:
fail-fast iterators (e.g., in ArrayList, HashMap) throw ConcurrentModificationException if the collection is modified structurally during iteration (except via remove()).
Example:

import java.util.ArrayList;
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2));
        for (Integer i : list) {
            list.add(3); // Throws ConcurrentModificationException
        }
    }
}

17. What is the fail-safe behavior in collections?

Answer:
fail-safe collections (e.g., CopyOnWriteArrayList, ConcurrentHashMap) allow modification during iteration by working on a copy or concurrent design, avoiding exceptions.
Example:

import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
    public static void main(String[] args) {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(new Integer[]{1, 2});
        for (Integer i : list) {
            list.add(3); // No exception
        }
        System.out.println(list); // [1, 2, 3, 3]
    }
}

18. What is the Collections.synchronizedList() method?

Answer:
Collections.synchronizedList() wraps a List to make it thread-safe by synchronizing all methods. However, iteration still requires manual synchronization.
Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        list.add("A");
        System.out.println(list); // [A]
    }
}

19. How does TreeMap maintain order?

Answer:
TreeMap uses a red-black tree to store key-value pairs, sorted by keys’ natural ordering or a Comparator. Operations like put(), get() are O(log n).
Example:

import java.util.TreeMap;
public class Test {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(3, "C");
        map.put(1, "A");
        System.out.println(map.keySet()); // [1, 3]
    }
}

20. What is the WeakHashMap, and when is it useful?

Answer:
WeakHashMap uses weak references for keys, allowing garbage collection if no strong references exist. It’s useful for caching where memory efficiency is critical.
Example:

import java.util.WeakHashMap;
public class Test {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> map = new WeakHashMap<>();
        String key = new String("Key");
        map.put(key, 1);
        key = null; // Eligible for GC
        System.gc();
        System.out.println(map); // May be empty
    }
}

Exception Handling

1. What is an exception in Java, and why is it important?

Answer:
An exception is an event that disrupts the normal flow of a program, typically due to errors like invalid input or resource unavailability. It’s important because it allows developers to handle errors gracefully, preventing crashes and improving reliability. Java uses a hierarchy rooted at Throwable (Error and Exception).
Example:

public class Test {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage()); // / by zero
        }
    }
}

2. What is the difference between checked and unchecked exceptions?

Answer:

• Checked Exceptions: Must be handled or declared (e.g., IOException). Extend Exception but not RuntimeException.
• Unchecked Exceptions: Optional to handle (e.g., NullPointerException). Extend RuntimeException.
  Key Point: Checked exceptions enforce error handling at compile time.
  Example:

import java.io.*;
public class Test {
    public static void main(String[] args) {
        // Checked exception
        try {
            new FileReader("file.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found");
        }
        // Unchecked exception
        String s = null;
        System.out.println(s.length()); // NullPointerException
    }
}

3. What is the purpose of the try, catch, and finally blocks?

Answer:

• try: Contains code that might throw an exception.
• catch: Handles the exception if thrown.
• finally: Executes regardless of whether an exception occurs (e.g., for cleanup).
  Example:

public class Test {
    public static void main(String[] args) {
        try {
            int[] arr = new int[2];
            arr[5] = 10;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Index error");
        } finally {
            System.out.println("Cleanup done");
        }
    }
}

4. What is the throw keyword used for?

Answer:
The throw keyword manually throws an exception to signal an error condition. It’s often used with custom exceptions or to propagate errors.
Example:

public class Test {
    static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be 18 or older");
        }
        System.out.println("Age is valid");
    }

    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

5. What is the throws keyword, and how does it differ from throw?

Answer:

• throws: Declares that a method can throw one or more exceptions, delegating handling to the caller.
• throw: Actively throws an exception in code.
  Example:

import java.io.IOException;
public class Test {
    static void riskyMethod() throws IOException {
        throw new IOException("I/O error");
    }

    public static void main(String[] args) {
        try {
            riskyMethod();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

6. How do you create a custom exception in Java?

Answer:
Create a custom exception by extending Exception (checked) or RuntimeException (unchecked). Add constructors for flexibility.
Example:

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

public class Test {
    static void validate(int value) throws MyException {
        if (value < 0) {
            throw new MyException("Value cannot be negative");
        }
    }

    public static void main(String[] args) {
        try {
            validate(-5);
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }
}

7. What is exception propagation?

Answer:
Exception propagation occurs when an exception is thrown in a method and not handled locally, passing it up the call stack until caught or the program terminates.
Example:

public class Test {
    static void method1() {
        int x = 10 / 0; // Exception thrown
    }
    static void method2() { method1(); }
    public static void main(String[] args) {
        try {
            method2();
        } catch (ArithmeticException e) {
            System.out.println("Caught in main: " + e);
        }
    }
}

8. What is the difference between Error and Exception?

Answer:

• Error: Serious problems (e.g., OutOfMemoryError) that applications typically cannot recover from. Extends Throwable.
• Exception: Recoverable conditions (e.g., IOException) that programs can handle. Extends Throwable.
  Key Point: Don’t catch Error unless absolutely necessary.

9. What is multi-catch in Java, and how does it work?

Answer:
Multi-catch (Java 7+) allows catching multiple exception types in a single catch block using |. Reduces code duplication.
Example:

public class Test {
    public static void main(String[] args) {
        try {
            String s = null;
            System.out.println(s.length());
            int x = Integer.parseInt("abc");
        } catch (NullPointerException | NumberFormatException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

10. What is the try-with-resources statement?

Answer:
Try-with-resources (Java 7+) automatically closes resources (e.g., files, sockets) that implement AutoCloseable. It simplifies resource management.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("file.txt")) {
            fr.read();
        } catch (IOException e) {
            System.out.println("IO Error: " + e);
        }
    }
}

11. Can a finally block be skipped?

Answer:
Yes, a finally block can be skipped if:

• System.exit() is called.
• The JVM crashes (e.g., power failure).
  Normally, it always executes after try/catch.
  Example:

public class Test {
    public static void main(String[] args) {
        try {
            System.out.println("Try");
            System.exit(0);
        } finally {
            System.out.println("Finally"); // Skipped
        }
    }
}

12. What happens if an exception is thrown in a finally block?

Answer:
If an exception is thrown in finally, it overrides any exception from try or catch, potentially masking the original issue.
Example:

public class Test {
    public static void main(String[] args) {
        try {
            throw new RuntimeException("Try exception");
        } finally {
            throw new RuntimeException("Finally exception"); // Masks try exception
        }
    }
}

13. What are best practices for exception handling?

Answer:

• Catch specific exceptions first, then general ones.
• Avoid catching Throwable or Error.
• Use try-with-resources for resource management.
• Log exceptions meaningfully.
• Don’t suppress exceptions silently.
  Example:

import java.io.*;
public class Test {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
            br.readLine();
        } catch (FileNotFoundException e) {
            System.err.println("File not found: " + e);
        } catch (IOException e) {
            System.err.println("IO error: " + e);
        }
    }
}

14. What is the Exception hierarchy in Java?

Answer:

• Throwable: Root class (parent of Error and Exception).
• Error: System-level issues (e.g., StackOverflowError).
• Exception: Application-level issues (e.g., IOException, RuntimeException).
• RuntimeException: Subclass of Exception for unchecked exceptions.

15. Can you override a method and change its exception declaration?

Answer:
Yes, but:

• Subclass method can throw fewer or narrower exceptions.
• Cannot throw broader or additional checked exceptions.
  Example:

class Parent {
    void method() throws IOException {}
}

class Child extends Parent {
    @Override
    void method() {} // No exception or narrower is fine
}

16. What is the purpose of the getMessage() and printStackTrace() methods?

Answer:

• getMessage(): Returns the exception’s detail message.
• printStackTrace(): Prints the stack trace for debugging.
  Example:

public class Test {
    public static void main(String[] args) {
        try {
            throw new Exception("Something went wrong");
        } catch (Exception e) {
            System.out.println(e.getMessage()); // Something went wrong
            e.printStackTrace(); // Full stack trace
        }
    }
}

17. What is exception chaining?

Answer:
Exception chaining links one exception to another (cause) using initCause() or a constructor, helping trace root causes.
Example:

public class Test {
    static void method() throws Exception {
        try {
            int x = 1 / 0;
        } catch (ArithmeticException e) {
            throw new Exception("Calculation failed", e);
        }
    }

    public static void main(String[] args) {
        try {
            method();
        } catch (Exception e) {
            System.out.println(e.getCause()); // ArithmeticException
        }
    }
}

18. What is the difference between NoSuchMethodException and NoSuchMethodError?

Answer:

• NoSuchMethodException: An Exception thrown at runtime (e.g., reflection fails).
• NoSuchMethodError: An Error thrown when a method is missing at runtime due to linking issues.
  Example:

import java.lang.reflect.*;
public class Test {
    public static void main(String[] args) {
        try {
            Class<?> cls = Class.forName("java.lang.String");
            cls.getMethod("nonExistent");
        } catch (NoSuchMethodException e) {
            System.out.println("Method not found");
        }
    }
}

19. How does Java handle multiple exceptions in a single try block?

Answer:
Multiple exceptions are caught in order of specificity (subclass to superclass). Only the first matching catch executes.
Example:

public class Test {
    public static void main(String[] args) {
        try {
            String s = null;
            s.length();
            int x = Integer.parseInt("abc");
        } catch (NullPointerException e) {
            System.out.println("NPE");
        } catch (RuntimeException e) {
            System.out.println("Other runtime error");
        }
    }
}

20. What is the role of the StackTraceElement class?

Answer:
StackTraceElement represents a single stack frame in a stack trace, providing method, file, and line number details. Accessed via getStackTrace().
Example:

public class Test {
    public static void main(String[] args) {
        try {
            throw new Exception("Test");
        } catch (Exception e) {
            StackTraceElement[] stack = e.getStackTrace();
            for (StackTraceElement element : stack) {
                System.out.println(element.getMethodName() + " at line " + element.getLineNumber());
            }
        }
    }
}

JVM Internals

1. What is the JVM, and what are its main components?

Answer:
The JVM (Java Virtual Machine) is an abstract machine that executes Java bytecode. It enables platform independence by interpreting or compiling bytecode to native machine code.
Main Components:

• Class Loader: Loads .class files.
• Runtime Data Areas: Memory areas (e.g., heap, stack).
• Execution Engine: Interprets or compiles bytecode (includes JIT compiler and garbage collector).

2. What is the role of the class loader in the JVM?

Answer:
The class loader loads, links, and initializes .class files into the JVM.
Sub-processes:

• Loading: Reads bytecode into memory.
• Linking: Verifies, prepares (allocates memory), and resolves references.
• Initialization: Executes static initializers.
  Types: Bootstrap, Extension, Application.
  Example:

public class Test {
    static { System.out.println("Class loaded"); }
    public static void main(String[] args) {
        System.out.println("Running");
    }
}

3. What are the different memory areas in the JVM?

Answer:

• Heap: Stores objects and arrays, shared across threads, managed by GC.
• Method Area: Stores class metadata (e.g., bytecode, constant pool).
• Stack: Per-thread, stores method frames (local variables, operands).
• PC Register: Per-thread, holds the address of the current instruction.
• Native Method Stack: For native method calls.

4. What is garbage collection, and how does it work in the JVM?

Answer:
Garbage collection (GC) reclaims memory from objects no longer referenced. It uses a mark-and-sweep algorithm:

• Mark: Identifies reachable objects from roots (e.g., stack, static variables).
• Sweep: Frees memory of unreachable objects.
  The JVM’s GC runs automatically, pausing threads briefly (stop-the-world).
  Example:

public class Test {
    public static void main(String[] args) {
        Object obj = new Object();
        obj = null; // Eligible for GC
        System.gc(); // Suggests GC (not guaranteed)
    }
}

5. What are the different types of garbage collectors in Java?

Answer:

• Serial GC: Single-threaded, for small apps.
• Parallel GC: Multi-threaded, throughput-focused.
• CMS (Concurrent Mark Sweep): Low-latency, concurrent collection (deprecated in Java 9).
• G1 GC: Region-based, balances throughput and latency (default since Java 9).
• ZGC/Shenandoah: Ultra-low-pause collectors (experimental/advanced).
  Key Point: Use -XX:+UseG1GC to enable G1.

6. What is the difference between the young generation and old generation in the heap?

Answer:

• Young Generation: For short-lived objects (Eden + Survivor spaces). Uses minor GC.
• Old Generation: For long-lived objects (Tenured space). Uses major GC.
  Objects move from young to old via aging (surviving multiple minor GCs).

7. What is the purpose of the JIT compiler?

Answer:
The Just-In-Time (JIT) compiler converts frequently executed bytecode into native machine code at runtime, improving performance over interpretation. It uses profiling to optimize hot spots.
Key Point: Combines interpreter speed with compiled code efficiency.

8. What is the difference between minor GC and major GC?

Answer:

• Minor GC: Cleans the young generation (Eden, Survivor). Fast, frequent.
• Major GC: Cleans the old generation (and sometimes young). Slower, less frequent.
  Full GC: Cleans the entire heap (stop-the-world event).

9. What is the metaspace in JVM?

Answer:
Metaspace (replaced PermGen in Java 8) stores class metadata (e.g., method bytecode, constant pool). It’s native memory, dynamically sized (unlike PermGen’s fixed size), reducing OutOfMemoryError.
Key Point: Controlled via -XX:MaxMetaspaceSize.

10. How does the JVM handle class loading delegation?

Answer:
The JVM uses a parent-first delegation model:

• Bootstrap Class Loader: Loads core classes (e.g., java.lang.*).
• Extension Class Loader: Loads extension classes (e.g., /lib/ext).
• Application Class Loader: Loads app-specific classes.
  Child loaders delegate to parents first, ensuring uniqueness.

11. What is the purpose of the finalize() method?

Answer:
The finalize() method is called by the GC before an object is reclaimed, allowing cleanup. It’s deprecated (Java 9) due to unpredictability—use try-with-resources or AutoCloseable instead.
Example:

class Resource {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalized");
    }
}

public class Test {
    public static void main(String[] args) {
        Resource r = new Resource();
        r = null;
        System.gc();
    }
}

12. What is a memory leak in the context of the JVM?

Answer:
A memory leak occurs when objects remain in memory despite no longer being needed, due to unintended references (e.g., static fields, caches). GC can’t reclaim them.
Example:

import java.util.ArrayList;
public class Test {
    static ArrayList<Object> leak = new ArrayList<>();
    public static void main(String[] args) {
        while (true) {
            leak.add(new Object()); // Grows indefinitely
        }
    }
}

13. What is the role of the permanent generation (PermGen)?

Answer:
PermGen (pre-Java 8) was a fixed-size heap area for class metadata and string pool. It was prone to OutOfMemoryError and replaced by Metaspace in Java 8 for better scalability.

14. How does the JVM manage stack memory?

Answer:
Each thread has a private stack for method calls, storing frames with local variables, operands, and return addresses. Stack size is set via -Xss. Overflow causes StackOverflowError.
Example:

public class Test {
    static void recurse() { recurse(); }
    public static void main(String[] args) {
        try {
            recurse();
        } catch (StackOverflowError e) {
            System.out.println("Stack overflow");
        }
    }
}

15. What is the string pool, and how does it work?

Answer:
The string pool (part of the heap) stores unique string literals to save memory. Managed by String.intern(). Moved from PermGen to heap in Java 7.
Example:

public class Test {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hello";
        System.out.println(s1 == s2); // true (same pool reference)
    }
}

16. What are JVM tuning options, and why are they used?

Answer:
JVM tuning options (e.g., -Xms, -Xmx, -XX:+UseG1GC) adjust memory, GC, and performance. Used to optimize throughput, latency, or memory usage.

• -Xms: Initial heap size.
• -Xmx: Maximum heap size.
  Example: Run java -Xms512m -Xmx1024m Test.

17. What is the difference between heap and non-heap memory?

Answer:

• Heap: Managed by GC, stores objects (e.g., Young, Old).
• Non-Heap: Outside GC, includes Metaspace, stack, native memory.

18. What is a class file, and how does the JVM use it?

Answer:
A class file contains bytecode generated by javac. The JVM loads it via the class loader, verifies it, and executes it using the execution engine.

19. What is the role of the bytecode verifier?

Answer:
The bytecode verifier (part of linking) ensures bytecode is valid and safe (e.g., no illegal casts, stack overflows). It enhances security and stability.

20. How does the JVM handle native methods?

Answer:
Native methods (written in C/C++) are called via JNI (Java Native Interface). The JVM uses the native method stack and links to native libraries (e.g., .dll, .so).
Example:

public class Test {
    native void nativeMethod();
    static { System.loadLibrary("nativeLib"); }
    public static void main(String[] args) {
        new Test().nativeMethod();
    }
}

Java I/O and NIO

1. What is Java I/O, and what are its main components?

Answer:
Java I/O (Input/Output) handles data reading and writing, primarily via streams in the java.io package.
Main Components:

• Byte Streams: InputStream, OutputStream (e.g., files).
• Character Streams: Reader, Writer (e.g., text).
• Buffered Streams: Improve performance (e.g., BufferedReader).

2. What is the difference between byte streams and character streams?

Answer:

• Byte Streams: Handle raw bytes (e.g., FileInputStream), used for binary data.
• Character Streams: Handle characters with encoding (e.g., FileReader), used for text.
  Example:

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (FileInputStream fis = new FileInputStream("test.txt")) {
            int data = fis.read(); // Byte stream
            System.out.println((char) data);
        }
    }
}

3. What is the purpose of buffered streams?

Answer:
Buffered streams (e.g., BufferedInputStream, BufferedReader) reduce direct access to underlying resources (e.g., files) by reading/writing in chunks, improving efficiency.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            System.out.println(br.readLine());
        }
    }
}

4. How do you read from a file using Java I/O?

Answer:
Use FileReader or FileInputStream with buffering for efficiency. Try-with-resources ensures proper closure.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5. How do you write to a file using Java I/O?

Answer:
Use FileWriter or FileOutputStream, often with BufferedWriter for text.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, Java!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. What is serialization in Java, and how is it implemented?

Answer:
Serialization converts an object into a byte stream for storage or transmission. It’s implemented by implementing Serializable and using ObjectOutputStream.
Example:

import java.io.*;
class Person implements Serializable {
    String name;
    Person(String name) { this.name = name; }
}

public class Test {
    public static void main(String[] args) throws IOException {
        Person p = new Person("Alice");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(p);
        }
    }
}

7. How do you deserialize an object in Java?

Answer:
Deserialization reconstructs an object from a byte stream using ObjectInputStream.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person p = (Person) ois.readObject();
            System.out.println(p.name); // Alice
        }
    }
}

8. What is the purpose of the transient keyword in serialization?

Answer:
The transient keyword excludes a field from serialization, useful for sensitive or non-serializable data.
Example:

import java.io.*;
class User implements Serializable {
    String name;
    transient String password;
    User(String name, String password) { this.name = name; this.password = password; }
}

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User u = new User("Bob", "secret");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            oos.writeObject(u);
        }
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
            User deserialized = (User) ois.readObject();
            System.out.println(deserialized.password); // null
        }
    }
}

9. What is Java NIO, and how does it differ from Java I/O?

Answer:
Java NIO (New I/O, java.nio) provides non-blocking I/O with channels, buffers, and selectors, unlike the blocking stream-based Java I/O.

• I/O: Stream-oriented, blocking.
• NIO: Buffer-oriented, non-blocking, scalable.

10. What are channels and buffers in Java NIO?

Answer:

• Channels: Bidirectional data conduits (e.g., FileChannel).
• Buffers: Memory blocks for data transfer (e.g., ByteBuffer).
  Example:

import java.nio.*;
import java.nio.channels.*;
import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (FileChannel channel = new RandomAccessFile("test.txt", "r").getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            channel.read(buffer);
            buffer.flip();
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
        }
    }
}

11. What is the purpose of the Selector class in NIO?

Answer:
Selector enables a single thread to manage multiple channels (e.g., sockets) for non-blocking I/O, using multiplexing.
Key Point: Ideal for scalable network apps.

12. How do you copy a file using Java NIO?

Answer:
Use Files.copy() or FileChannel.transferTo() for efficient file copying.
Example:

import java.nio.file.*;
public class Test {
    public static void main(String[] args) throws IOException {
        Path source = Paths.get("source.txt");
        Path target = Paths.get("target.txt");
        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
    }
}

13. What is the difference between blocking and non-blocking I/O?

Answer:

• Blocking I/O: Thread waits until the operation completes (e.g., InputStream.read()).
• Non-blocking I/O: Thread continues, checking readiness (e.g., NIO Channel).
  Key Point: NIO supports both; I/O is blocking only.

14. How do you read a file line by line using NIO?

Answer:
Use Files.newBufferedReader() or Files.lines() (Java 8+) for simplicity.
Example:

import java.nio.file.*;
import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        Files.lines(Paths.get("test.txt")).forEach(System.out::println);
    }
}

15. What is the Path interface in NIO?

Answer:
Path (from java.nio.file) represents a file system path in a platform-independent way, replacing File.
Example:

import java.nio.file.*;
public class Test {
    public static void main(String[] args) {
        Path path = Paths.get("test.txt");
        System.out.println(path.getFileName()); // test.txt
    }
}

16. What is the Files class, and what are its common methods?

Answer:
Files is a utility class for file operations (e.g., copy(), readAllLines(), write()).
Example:

import java.nio.file.*;
public class Test {
    public static void main(String[] args) throws IOException {
        Files.writeString(Paths.get("output.txt"), "Hello");
    }
}

17. How does NIO support asynchronous I/O?

Answer:
NIO.2 (Java 7) provides AsynchronousFileChannel and Future/CompletionHandler for non-blocking I/O.
Example:

import java.nio.*;
import java.nio.channels.*;
import java.io.*;
public class Test {
    public static void main(String[] args) throws Exception {
        try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get("test.txt"))) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            java.util.concurrent.Future<Integer> result = channel.read(buffer, 0);
            System.out.println("Bytes read: " + result.get());
        }
    }
}

18. What is the RandomAccessFile class, and how is it used?

Answer:
RandomAccessFile allows reading/writing at any file position using a seek pointer.
Example:

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (RandomAccessFile raf = new RandomAccessFile("test.txt", "rw")) {
            raf.seek(5); // Move to position 5
            raf.write("Test".getBytes());
        }
    }
}

19. What is the difference between File and Path?

Answer:

• File: Older java.io class, less flexible.
• Path: NIO’s modern replacement, richer API, platform-independent.
  Example:

import java.io.File;
import java.nio.file.*;
public class Test {
    public static void main(String[] args) {
        File file = new File("test.txt");
        Path path = file.toPath(); // Convert File to Path
    }
}

20. How do you handle file locking in Java NIO?

Answer:
Use FileLock with FileChannel to lock files, preventing concurrent access.
Example:

import java.nio.channels.*;
import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        try (RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
             FileChannel channel = raf.getChannel()) {
            FileLock lock = channel.lock();
            System.out.println("File locked");
            lock.release();
        }
    }
}

Lambda Expressions & Streams API

1. What are lambda expressions in Java?

Answer:
Lambda expressions (Java 8+) provide a concise way to represent anonymous functions, enabling functional programming. They implement functional interfaces (one abstract method).
Syntax: (parameters) -> expression or (parameters) -> { statements; }
Example:

import java.util.function.Predicate;
public class Test {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(4)); // true
    }
}

2. What is a functional interface?

Answer:
A functional interface has exactly one abstract method and can be used with lambda expressions. Annotated with @FunctionalInterface for clarity.
Example:

@FunctionalInterface
interface MyFunction {
    void apply(String s);
}

public class Test {
    public static void main(String[] args) {
        MyFunction func = s -> System.out.println(s);
        func.apply("Hello"); // Hello
    }
}

3. What are the benefits of lambda expressions?

Answer:

• Concise code for anonymous functions.
• Enables functional programming (e.g., passing behavior).
• Works seamlessly with Streams API for data processing.
  Example:

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        Arrays.asList(1, 2, 3).forEach(n -> System.out.println(n));
    }
}

4. What is the Streams API, and how does it work?

Answer:
The Streams API (Java 8+) processes collections declaratively using functional-style operations. A stream is a sequence of elements supporting operations like filter, map, and reduce.
Key Point: Streams are lazy; operations execute only when a terminal operation (e.g., collect()) is invoked.
Example:

import java.util.stream.*;
import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        Stream<Integer> stream = list.stream();
        stream.filter(n -> n % 2 == 0).forEach(System.out::println); // 2, 4
    }
}

5. What is the difference between stream() and parallelStream()?

Answer:

• stream(): Sequential processing, single-threaded.
• parallelStream(): Parallel processing, multi-threaded, uses ForkJoinPool.
  Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        list.parallelStream().forEach(System.out::println); // Unordered output
    }
}

6. What are intermediate and terminal operations in Streams?

Answer:

• Intermediate: Transform a stream, lazy (e.g., filter(), map()).
• Terminal: Produce a result or side-effect, triggers execution (e.g., collect(), forEach()).
  Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "bb", "ccc");
        long count = list.stream() // Intermediate: filter
                         .filter(s -> s.length() > 1)
                         .count(); // Terminal: count
        System.out.println(count); // 2
    }
}

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

Answer:
filter() retains elements matching a predicate, producing a new stream.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream().filter(n -> n > 3).forEach(System.out::println); // 4, 5
    }
}

8. What does the map() method do in Streams?

Answer:
map() transforms each element using a function, producing a new stream of transformed elements.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        list.stream().map(String::toUpperCase).forEach(System.out::println); // A, B, C
    }
}

9. What is the reduce() method in Streams?

Answer:
reduce() combines stream elements into a single result using an accumulator (e.g., sum, product).
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        int sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum); // 10
    }
}

10. What is the collect() method, and how is it used?

Answer:
collect() gathers stream elements into a collection or other result using a Collector.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        List<String> result = list.stream().filter(s -> s.startsWith("a"))
                                          .collect(Collectors.toList());
        System.out.println(result); // [apple]
    }
}

11. What are method references, and how do they relate to lambdas?

Answer:
Method references (::) are shorthand for lambda expressions that invoke existing methods. Types: static, instance, constructor.
Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.forEach(System.out::println); // Method reference
    }
}

12. What is the Optional class, and how does it work with Streams?

Answer:
Optional (Java 8+) wraps a potentially null value, reducing NullPointerException. Streams return Optional for operations like findFirst().
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b");
        Optional<String> first = list.stream().findFirst();
        first.ifPresent(System.out::println); // a
    }
}

13. How does the flatMap() method work in Streams?

Answer:
flatMap() flattens nested streams into a single stream, useful for collections within collections.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<List<Integer>> list = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));
        list.stream().flatMap(Collection::stream).forEach(System.out::println); // 1, 2, 3, 4
    }
}

14. What is the sorted() method in Streams?

Answer:
sorted() orders stream elements naturally or via a Comparator.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(3, 1, 4, 1);
        list.stream().sorted().forEach(System.out::println); // 1, 1, 3, 4
    }
}

15. What are the peek() and forEach() methods, and how do they differ?

Answer:

• peek(): Intermediate, inspects elements without consuming the stream.
• forEach(): Terminal, performs an action and ends the stream.
  Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().peek(n -> System.out.println("Peek: " + n))
                     .filter(n -> n > 1)
                     .forEach(n -> System.out.println("ForEach: " + n));
    }
}

16. How do you create a Stream in Java?

Answer:
Streams can be created from collections, arrays, or static methods like Stream.of().
Example:

import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("a", "b", "c");
        stream.forEach(System.out::println);
    }
}

17. What is lazy evaluation in Streams?

Answer:
Lazy evaluation delays stream operations until a terminal operation is called, optimizing performance by avoiding unnecessary work.
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        Stream<Integer> stream = list.stream().filter(n -> {
            System.out.println("Filtering: " + n);
            return n > 1;
        });
        // No output yet (lazy)
        stream.forEach(System.out::println); // Triggers execution
    }
}

18. What are the built-in functional interfaces in Java?

Answer:
Key interfaces in java.util.function:

• Predicate<T>: Tests a condition.
• Function<T, R>: Transforms input to output.
• Consumer<T>: Performs an action.
• Supplier<T>: Provides a value.
  Example:

import java.util.function.*;
public class Test {
    public static void main(String[] args) {
        Consumer<String> print = System.out::println;
        print.accept("Hello"); // Hello
    }
}

19. How do you handle exceptions in lambda expressions?

Answer:
Wrap the lambda body in a try-catch or delegate to a method that handles exceptions.
Example:

import java.util.*;
public class Test {
    static void process(String s) {
        try {
            Integer.parseInt(s);
        } catch (NumberFormatException e) {
            System.out.println("Invalid: " + s);
        }
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "abc", "3");
        list.forEach(Test::process);
    }
}

20. What is the Collectors class, and what are some common collectors?

Answer:
Collectors provides utilities for collect() (e.g., toList(), toMap(), joining()).
Example:

import java.util.*;
import java.util.stream.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        String result = list.stream().collect(Collectors.joining(", "));
        System.out.println(result); // a, b, c
    }
}

Additional Crucial Java Interview Questions

1. What is the difference between String, StringBuilder, and StringBuffer?

Answer:

• String: Immutable, thread-safe by default, creates new objects for modifications.
• StringBuilder: Mutable, not thread-safe, faster for single-threaded operations.
• StringBuffer: Mutable, thread-safe (synchronized), slower due to locking.
  Example:

public class Test {
    public static void main(String[] args) {
        String s = "Hello";
        s = s + " World"; // New object
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World"); // Same object
        System.out.println(s.equals(sb.toString())); // true
    }
}

2. What is the static keyword, and how does it work?

Answer:
The static keyword denotes class-level members (variables, methods, blocks) that belong to the class, not instances.

• Variables: Shared across all objects.
• Methods: Called without instantiation.
• Blocks: Executed once during class loading.
  Example:

public class Test {
    static int count = 0;
    static { System.out.println("Static block"); }
    static void increment() { count++; }

    public static void main(String[] args) {
        Test.increment();
        System.out.println(Test.count); // 1
    }
}

3. What are Java annotations, and how are they used?

Answer:
Annotations are metadata tags (e.g., @Override, @Deprecated) that provide information to the compiler, runtime, or tools. Custom annotations can be created.
Example:

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation {
    String value();
}

public class Test {
    @MyAnnotation("example")
    public void myMethod() {}

    public static void main(String[] args) throws Exception {
        MyAnnotation ann = Test.class.getMethod("myMethod").getAnnotation(MyAnnotation.class);
        System.out.println(ann.value()); // example
    }
}

4. What is the difference between public, protected, default, and private access modifiers?

Answer:

• public: Accessible everywhere.
• protected: Accessible in the same package and subclasses (even outside package).
• default (package-private): Accessible only in the same package if no modifier is specified.
• private: Accessible only within the class.
  Example:

class Parent {
    public int pub = 1;
    protected int pro = 2;
    int def = 3;
    private int priv = 4;
}

class Child extends Parent {
    void test() {
        System.out.println(pub); // OK
        System.out.println(pro); // OK
        System.out.println(def); // OK if same package
        // System.out.println(priv); // Error
    }
}

5. What is the volatile keyword, and when should you use it?

Answer:
volatile ensures a variable’s value is always read from/written to main memory, not thread-local caches, preventing visibility issues in multithreading. Use it for simple flags or counters without complex synchronization.
Example:

public class Test {
    volatile static boolean running = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (running) {}
            System.out.println("Stopped");
        }).start();
        Thread.sleep(1000);
        running = false; // Visible to other thread
    }
}

6. What is the purpose of the transient keyword outside serialization?

Answer:
While primarily used in serialization to exclude fields, transient can also signal intent in non-serializable contexts (e.g., temporary state), though it has no runtime effect outside serialization.
Example:

class Data {
    transient int temp = 42; // Indicates temporary, ignored in serialization
}

7. What is dependency injection, and how is it implemented in Java?

Answer:
Dependency injection (DI) provides dependencies to a class rather than the class creating them, promoting loose coupling. In Java, it’s often implemented manually or via frameworks like Spring.
Example (Manual DI):

interface Service { void serve(); }
class ServiceImpl implements Service {
    public void serve() { System.out.println("Serving"); }
}

class Client {
    private Service service;
    Client(Service service) { this.service = service; } // Injection
    void doWork() { service.serve(); }
}

public class Test {
    public static void main(String[] args) {
        Client client = new Client(new ServiceImpl());
        client.doWork();
    }
}

8. What is the Comparable vs. Comparator debate in sorting?

Answer:

• Comparable: Natural ordering, implemented by the class itself (compareTo()).
• Comparator: External, custom ordering, more flexible (compare()).
  Example:

import java.util.*;
class Person implements Comparable<Person> {
    int age;
    Person(int age) { this.age = age; }
    public int compareTo(Person o) { return this.age - o.age; }
}

public class Test {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(new Person(30), new Person(20));
        Collections.sort(list);
        System.out.println(list.get(0).age); // 20
    }
}

9. What is the Java Memory Model (JMM)?

Answer:
The JMM defines how threads interact with memory, ensuring visibility and ordering of operations. It governs volatile, synchronized, and atomicity rules.
Key Point: Guarantees visibility with volatile or locks.

10. What are Java generics, and why are they useful?

Answer:
Generics enable type-safe collections and methods, reducing runtime errors and casting. They use <T> syntax.
Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Hello");
        String s = list.get(0); // No cast needed
        System.out.println(s);
    }
}

11. What is type erasure in Java generics?

Answer:
Type erasure removes generic type information at compile time, replacing it with raw types or bounds (e.g., Object), ensuring backward compatibility.
Example:

class Box<T> {
    T value;
    Box(T value) { this.value = value; }
}

12. What is the Class class, and how is it used for reflection?

Answer:
Class represents a class’s metadata at runtime. Reflection uses it to inspect or modify behavior dynamically.
Example:

public class Test {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = String.class;
        System.out.println(clazz.getMethod("length").getName()); // length
    }
}

13. What is the purpose of the assert keyword?

Answer:
assert tests assumptions during development/debugging, throwing AssertionError if false. Disabled by default (-ea enables).
Example:

public class Test {
    public static void main(String[] args) {
        int x = -1;
        assert x >= 0 : "x must be non-negative";
    }
}

14. What is the enum type in Java?

Answer:
enum defines a fixed set of constants, optionally with fields/methods, improving type safety over constants.
Example:

enum Day {
    MONDAY, TUESDAY;
    void print() { System.out.println(this); }
}

public class Test {
    public static void main(String[] args) {
        Day.MONDAY.print(); // MONDAY
    }
}

15. What is the var keyword in Java (Java 10+)?

Answer:
var enables local variable type inference, reducing verbosity while maintaining static typing.
Example:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        var list = new ArrayList<String>(); // Infers ArrayList<String>
        list.add("Hello");
        System.out.println(list);
    }
}

16. What is the difference between deep copy and shallow copy?

Answer:

• Shallow Copy: Copies object references, not nested objects (e.g., clone() by default).
• Deep Copy: Copies entire object graph, including nested objects.
  Example (Shallow):

class Box implements Cloneable {
    int value;
    Box(int value) { this.value = value; }
    public Object clone() throws CloneNotSupportedException { return super.clone(); }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Box b1 = new Box(10);
        Box b2 = (Box) b1.clone();
        System.out.println(b2.value); // 10
    }
}

17. What is the record type in Java (Java 14+)?

Answer:
record is a concise way to create immutable data classes with auto-generated constructors, getters, equals(), hashCode(), and toString().
Example:

record Point(int x, int y) {}

public class Test {
    public static void main(String[] args) {
        Point p = new Point(1, 2);
        System.out.println(p.x()); // 1
    }
}

18. What is the module system in Java (Java 9+)?

Answer:
The Java Platform Module System (JPMS) organizes code into modules, defined in module-info.java, improving encapsulation and dependency management.
Example:

// module-info.java
module my.module {
    exports com.example;
}

// com/example/MyClass.java
package com.example;
public class MyClass {
    public void sayHi() { System.out.println("Hi"); }
}

19. What is the switch expression in Java (Java 17)?

Answer:
switch expressions (enhanced in Java 17) return values concisely using -> and yield, replacing traditional switch statements.
Example:

public class Test {
    public static void main(String[] args) {
        int day = 2;
        String result = switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            default -> "Unknown";
        };
        System.out.println(result); // Tuesday
    }
}

20. What are sealed classes in Java (Java 17)?

Answer:
Sealed classes restrict which classes can extend or implement them, using sealed and permits. Enhances control over inheritance.
Example:

sealed class Shape permits Circle, Square {}
final class Circle extends Shape {}
final class Square extends Shape {}

public class Test {
    public static void main(String[] args) {
        Shape s = new Circle();
    }
}

Familiarity with Java Frameworks and Technologies

Experienced Java developers are expected to work with frameworks that streamline application development. Below is a comparison of key Java frameworks:

Comparison of Java Versions and Features

Each Java version introduces improvements and new features. Here’s a quick comparison:

Handling Specific Java Concepts Like Serialization and Deserialization

Serialization is essential for saving Java objects and transferring data. Key points include:

import java.io.*;
class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    int id;
    String name;
    Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

Candidates should be prepared to discuss how serialization works and how to optimize it.

Personal Project and Experience Sharing

Sharing personal projects showcases practical expertise. Some ideas include:

• Building a REST API with Spring Boot
• Creating a real-time chat application using WebSockets
• Developing an e-commerce application with Hibernate for database management

Employers value candidates who take initiative and apply their skills in real-world projects.

FAQs

1. How many Java interview questions for 5 years of experience?
Candidates should prepare for questions on core Java, multithreading, frameworks, and best practices.

2. How to get a job in Java with 5 years of experience?
Focus on strengthening problem-solving skills, mastering frameworks, and networking with professionals.

3. What is the Java interview process?
Typically includes coding tests, technical interviews, and discussions on projects and frameworks.

4. What questions are asked in Java interviews?
Expect questions on OOP, collections, exception handling, and JVM internals.

5. How to crack a Java interview with 5 years of experience?
Practice coding regularly, review system design concepts, and work on personal projects.

6. How to prepare for a Java interview?
Build a strong foundation in core Java, explore frameworks, and practice problem-solving daily.

Conclusion

Succeeding in a Java interview requires deep technical expertise and problem-solving skills. Candidates should focus on core Java concepts, frameworks, and best practices while also refining their soft skills. Continuous learning and hands-on experience will significantly boost interview performance.

Check out our MERN Stack course and kickstart your career:

Check out our MERN Stack course and kickstart your career: Cuvette Placement Guarantee Program