Top Core Java Interview Questions

1. What is Java, and what are its key features?

Java is a high-level, object-oriented programming language developed by Sun Microsystems (now owned by Oracle). It is platform-independent, meaning Java programs can run on any device with a Java Virtual Machine (JVM). Key features of Java include simplicity, portability, robustness, security, and multithreading. Java follows the “write once, run anywhere” (WORA) principle, making it ideal for developing cross-platform applications. It is widely used in web development, mobile applications (Android), enterprise applications, and big data technologies. Java’s extensive standard library and active community support further enhance its popularity and versatility.

2. What is the difference between JDK, JRE, and JVM?

The JDK (Java Development Kit) is a software development environment used to develop Java applications. It includes the JRE (Java Runtime Environment), compilers, and tools like javac and java. The JRE is the runtime environment that provides the libraries and JVM (Java Virtual Machine) needed to run Java programs. The JVM is an abstract machine that executes Java bytecode and provides platform independence. In summary, JDK is for development, JRE is for running Java programs, and JVM is the engine that executes the bytecode. Understanding these components is essential for Java development.

3. What is the difference between == and .equals() in Java?

The == operator in Java is used to compare primitive data types (e.g., int, char) by their values and reference types (e.g., objects) by their memory addresses. For example:

int a = 5, b = 5;
System.out.println(a == b); // true

The .equals() method is used to compare objects by their content. It is overridden in classes like String to compare the actual values of objects. For example:

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2)); // true

While == checks for reference equality, .equals() checks for value equality.

4. What is the difference between String, StringBuilder, and StringBuffer in Java?

String is an immutable sequence of characters, meaning its value cannot be changed after creation. Every modification creates a new String object, which can be inefficient for frequent changes. StringBuilder and StringBuffer are mutable sequences of characters, allowing modifications without creating new objects. StringBuilder is not thread-safe, making it faster, while StringBuffer is thread-safe but slower due to synchronization. For example:

StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // Modifies the same object

Use String for immutable data, StringBuilder for single-threaded environments, and StringBuffer for multi-threaded environments.

5. What is the purpose of the final keyword in Java?

The final keyword in Java is used to restrict modifications. It can be applied to variables, methods, and classes. A final variable cannot be reassigned, a final method cannot be overridden, and a final class cannot be extended. For example:

final int x = 10;
// x = 20; // Compilation error

The final keyword ensures immutability and security, making it useful for defining constants, preventing method overriding, and creating immutable classes.

6. What is the difference between ArrayList and LinkedList in Java?

ArrayList and LinkedList are both implementations of the List interface but differ in their internal structure and performance. ArrayList uses a dynamic array to store elements, providing fast random access and slower insertions/deletions in the middle. LinkedList uses a doubly linked list, providing faster insertions/deletions but slower random access. For example:

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("A"); // Fast for adding at the end
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("B"); // Fast for adding at the beginning

Use ArrayList for frequent read operations and LinkedList for frequent insertions/deletions.

7. What is the purpose of the static keyword in Java?

The static keyword in Java is used to define class-level variables and methods that belong to the class rather than instances of the class. A static variable is shared across all instances, and a static method can be called without creating an object. For example:

class Counter {
    static int count = 0;
    Counter() { count++; }
    static void displayCount() { System.out.println(count); }
}

static is useful for defining utility methods, constants, and shared resources. However, overusing static can lead to poor design and tight coupling.

8. What is the difference between HashMap and HashTable in Java?

HashMap and HashTable are both implementations of the Map interface but differ in synchronization and performance. HashMap is not synchronized, making it faster but not thread-safe. HashTable is synchronized, making it thread-safe but slower. HashMap allows one null key and multiple null values, while HashTable does not allow any null keys or values. For example:

HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put(null, 1); // Allowed
Hashtable<String, Integer> hashtable = new Hashtable<>();
// hashtable.put(null, 1); // Throws NullPointerException

Use HashMap for single-threaded environments and HashTable for multi-threaded environments.

9. What is the purpose of the this keyword in Java?

The this keyword in Java refers to the current instance of the class. It is used to differentiate between instance variables and method parameters with the same name. For example:

class Person {
    String name;
    Person(String name) {
        this.name = name; // Assigns parameter to instance variable
    }
}

this can also be used to call one constructor from another (constructor chaining) or to pass the current object as a parameter. It is essential for avoiding ambiguity and improving code readability.

10. What is the purpose of the super keyword in Java?

The super keyword in Java is used to refer to the parent class. It is used to call the parent class constructor, access parent class methods, or refer to parent class variables. For example:

class Animal {
    String sound = "Animal sound";
}
class Dog extends Animal {
    String sound = "Bark";
    void display() {
        System.out.println(super.sound); // Accesses parent class variable
    }
}

super is essential for inheritance and method overriding, ensuring proper initialization and behavior in subclass objects.

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

The finalize() method in Java is called by the garbage collector before an object is reclaimed. It can be overridden to perform cleanup operations, such as releasing resources. For example:

class MyClass {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("Object cleaned up");
    }
}

However, relying on finalize() is discouraged because its execution is not guaranteed. Instead, use try-with-resources or explicit cleanup methods for resource management.

12. What is the difference between throw and throws in Java?

The throw keyword in Java is used to explicitly throw an exception, while the throws keyword is used in method signatures to declare that a method might throw an exception. For example:

void myMethod() throws IOException {
    throw new IOException("Error occurred");
}

throw is used to raise an exception, and throws is used to indicate that the caller should handle the exception. Both are essential for exception handling in Java.

13. What is the purpose of the try-with-resources statement in Java?

The try-with-resources statement in Java is used to automatically close resources like files, sockets, or database connections. It ensures that resources are closed even if an exception occurs. For example:

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line = br.readLine();
} catch (IOException e) {
    e.printStackTrace();
}

try-with-resources simplifies resource management and eliminates the need for explicit finally blocks. It is a best practice for handling resources in Java.

14. What is the purpose of the transient keyword in Java?

The transient keyword in Java is used to indicate that a variable should not be serialized during object serialization. For example:

class User implements Serializable {
    transient String password; // Not serialized
}

transient is useful for excluding sensitive or temporary data from serialization, ensuring that it is not persisted or transmitted.

15. What is the purpose of the volatile keyword in Java?

The volatile keyword in Java is used to indicate that a variable’s value may be modified by multiple threads. It ensures visibility of changes across threads and prevents thread caching. For example:

volatile boolean flag = true;

volatile is useful for simple thread synchronization but does not provide atomicity. For complex synchronization, use synchronized or java.util.concurrent classes.

Certainly! Here are the next set of Core Java interview questions and detailed answers:

16. What is the purpose of the synchronized keyword in Java?

The synchronized keyword in Java is used to control access to shared resources in a multi-threaded environment. It ensures that only one thread can execute a synchronized method or block at a time, preventing race conditions. For example:

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

synchronized can be applied to methods or blocks of code. It is essential for thread safety but can lead to performance bottlenecks if overused. For better performance, consider using java.util.concurrent utilities like ReentrantLock.

17. What is the difference between wait() and sleep() in Java?

The wait() method in Java is used in multi-threading to make a thread wait until another thread notifies it. It releases the lock on the object and is called from a synchronized context. For example:

synchronized (obj) {
    obj.wait(); // Releases lock and waits
}

The sleep() method pauses the current thread for a specified time without releasing the lock. For example:

Thread.sleep(1000); // Pauses for 1 second

wait() is used for inter-thread communication, while sleep() is used for time-based pauses.

18. What is the purpose of the notify() and notifyAll() methods in Java?

The notify() method in Java wakes up a single thread that is waiting on the object’s monitor, while notifyAll() wakes up all waiting threads. Both methods are used in multi-threading for inter-thread communication. For example:

synchronized (obj) {
    obj.notify(); // Wakes up one waiting thread
    obj.notifyAll(); // Wakes up all waiting threads
}

notify() is useful when only one thread needs to proceed, while notifyAll() is used when multiple threads need to be awakened. Both methods must be called from a synchronized context.

19. What is the purpose of the join() method in Java?

The join() method in Java is used to make a thread wait until another thread completes its execution. It is useful for coordinating the execution of multiple threads. For example:

Thread t1 = new Thread(() -> System.out.println("Thread 1"));
Thread t2 = new Thread(() -> {
    try {
        t1.join(); // Waits for t1 to complete
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Thread 2");
});
t1.start();
t2.start();

join() ensures that the current thread waits for the specified thread to finish before proceeding.

20. What is the purpose of the ThreadLocal class in Java?

The ThreadLocal class in Java is used to create thread-local variables, meaning each thread has its own independent copy of the variable. It is useful for maintaining per-thread state, such as user sessions or transaction contexts. For example:

ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
threadLocal.set(1); // Sets value for the current thread
System.out.println(threadLocal.get()); // Gets value for the current thread

ThreadLocal ensures thread safety and avoids synchronization issues by providing isolated storage for each thread.

21. What is the purpose of the java.util.concurrent package in Java?

The java.util.concurrent package in Java provides utilities for concurrent programming, such as thread pools, concurrent collections, and synchronization mechanisms. It includes classes like ExecutorService, ConcurrentHashMap, and CountDownLatch. For example:

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("Task 1"));
executor.shutdown();

This package simplifies multi-threaded programming and improves performance by providing high-level abstractions for concurrency.

22. What is the purpose of the ExecutorService in Java?

The ExecutorService in Java is used to manage a pool of threads and execute tasks asynchronously. It provides methods for submitting tasks, shutting down the pool, and retrieving results. For example:

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("Task 1"));
executor.shutdown();

ExecutorService simplifies thread management and improves performance by reusing threads instead of creating new ones for each task.

23. What is the purpose of the Callable interface in Java?

The Callable interface in Java is similar to Runnable but can return a result and throw exceptions. It is used with ExecutorService to execute tasks that return values. For example:

Callable<Integer> task = () -> {
    return 42;
};
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(task);
System.out.println(future.get()); // 42
executor.shutdown();

Callable is useful for tasks that need to return results or handle exceptions.

24. What is the purpose of the Future interface in Java?

The Future interface in Java represents the result of an asynchronous computation. It provides methods to check if the computation is complete, retrieve the result, or cancel the task. For example:

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> 42);
System.out.println(future.get()); // 42
executor.shutdown();

Future is used with ExecutorService and Callable to handle asynchronous tasks and retrieve their results.

25. What is the purpose of the ConcurrentHashMap in Java?

The ConcurrentHashMap in Java is a thread-safe implementation of the Map interface. It provides better performance than Hashtable by allowing concurrent read and write operations without locking the entire map. For example:

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
System.out.println(map.get("key")); // 1

ConcurrentHashMap is ideal for high-concurrency environments where thread safety and performance are critical.