sudheerj/java-interview-questions

java-interview-questions

Frequently asked Java Interview questions

Table of Contents

1. What are the differences between JVM, JRE and JDK?

   The main differences between JVM, JRE and JDK are listed below,

   JVM: Java Virtual Machine(JVM) is an abstract machine that provides a runtime environment for the execution of Java ByteCode. i.e, It is part of Java Runtime Environment(JRE) and responsible for converting bytecode into machine-readable code. JVM is platform dependent but it interprets the bytecode which is platform independent. As a result, Java applications to run on different platforms and operating systems.

   JRE: Java Runtime Environment (JRE) is an installation package that provides Java Virtual Machine (JVM), class libraries and other components to run the Java program or application on any machine.

   JDK: Java Development Kit (JDK) is a software development kit used to develop and execute Java programs. It includes tools for developing, monitoring and debugging java programs, along with JRE to execute those respective programs.

   The pictorial representation of these three components looks as follows,

   

   ⬆ Back to Top

2. Why Java is platform-independent language

   Java is platform-independent language because java programs are compiled to a bytecode that can be run on any device or OS which has a Java Virtual Machine(JVM). This is possible due to JVM's "Write Once, Run Anywhere"(WORA) capability. Due to this reason, you can write a Java program on one platform such as Windows machine and then run it on a different platform such as macOS or Linux machine without making any modifications to the code.

   Below diagram explains the platform independence feature of Java,

   

   ⬆ Back to Top

3. How does JVM works

   JVM(Java Virtual Machine) is an abstract runtime engine to run java applications. It is part of Java Runtime Environment(JRE) to execute the bytecode generated by java compilers. JVM brings WORA(Write Once Read Anywhere) behavior in which you can write java program on one system and expected to run on any java enabled systems without any modifications. Upon compiling .java file to .class file(contains byte code), .class file goes into several steps described by JVM.

   JVM consists of three main components:

   1. Class Loader subsystem
   2. Runtime data area/ memory area
   3. Execution engine

   Let's understand the JVM architecture which includes the above three components,

   

   1. Class Loader Subsystem: The class loaders are responsible to load the class files dynamically into JVM during the runtime. The first class that loaded into the memory is usually the class that contains main method.This subsystem performs three main activities.

      1. Loading: As part of this step, the class loader will read the .class file and loads its bytecode into memory. The following important information of the class file will be saved in method area(Metaspace in modern JVMs) of JVM.

         1. The Fully Qualified Class Name(FQCN) of the loaded class.
         2. Immediate parent class.
         3. Variables and methods(i.e, constant pool),modifier information
         4. Whether .class is related to Class, Interface or Enum.

         JVM also creates an object of Class type(available from java.lang package) in the heap memory to represent that class at runtime. But it will be created only on the very first time when the class file is loaded into JVM. This object is helpful for the developers to get class level information.

         There are three built-in classloaders available in Java:

         1. Bootstrap ClassLoader: This is a root class loader and typically represented as null. It loads the core java libraries such as java.base (java.lang, java.util etc). This class loader is written in native code(C/C++) unlike other class loaders.

         2. Platform ClassLoader: This class loader is responsible for loading platform classes such as Java SE platform APIs, their implementation classes and JDK-specific run-time classes. For example, the platform classes such as java.net.http, java.sql, java.xml.

         3. System/Application classLoader: This class loader is responsible for loading all the classes configured from the classpath. The classpath can contain classes from directories, JAR files etc.

      The class loaders follow a Parent Delegation Model. When a class is requested, the Application ClassLoader first delegates the request to its parent (Platform ClassLoader), which further delegates to the Bootstrap ClassLoader. If the parent cannot find the class, then the child class loader attempts to load it.

      Note: Apart from the above built-in class loaders, you can also create your own user defined class loader for ensuring application independence. For example, Tomcat webserver use this approach(WebAppClassLoader) to ensure that different web applications to load and isolate classes/jars.

      2. Linking: Linking is the process of taking a class or interface and combining it into the runtime state of the Java virtual machine, preparing it for execution. It involves the following steps:

         1. Verification: This phase ensure the correctness of .class file by checking whether the file is properly formatted or not, and ensures it follows JVM bytecode specifications. If the validation is failed, you will receive java.lang.VerifyError through ByteCodeVerifier.

         2. Preparation: In this step, JVM allocates memory for all static variables within classes/interfaces and assign them with default values(0, null, false, etc.).

         3. Resolution: In this step, symbolic references in the runtime constant pool are replaced with direct references to classes, methods, or fields. This process may occur at linking time or lazily at runtime, and is part of dynamic linking..

      3. Initialization: This is the final phase of class loading. During this phase, static variables are assigned their actual values as defined in the class, and static blocks are executed. The JVM executes a special method called () to perform this initialization.

   2. Runtime data area/ memory area:

      The runtime data areas are mainly divided into five components,

      1. Method: The method area stores below class level information,

         1. ClassLoader reference
         2. Runtime constant pool
         3. Field data such as name, type, modifiers, attributes etc of each field.
         4. Method data such as name, return type, modifiers, attributes, parameter types etc of each method.
         5. Constructor data such as parameter types and their order for each constructor.

      This is a shared resource and only one method area is available per JVM.

      2. Heap: This is the runtime data area in which all the objects and their respective instance variables are stored. The heap is created upon JVM startup and there is only one heap per JVM.

      3. Stack: Each thread which is created in JVM, a separate runtime-stack is also created at the same time. The local variables, method calls and intermediate results are stored in this stack area. But if the thread requires a larger stack size than what is available, JVM throws java.lang.StackOverflowError error.

      For each method call, a stack frame is created in the stack memory area and it is going to be destroyed upon method execution gets completed. Each stack frame is further divided into three sections.

      1. Local variables: For each frame, all the local variables and their values are stored in an array format.
      2. Operand stack: In each frame, the variables and operators required for mathematical operations are stored in LIFO stack.
      3. Frame data: This area holds all symbolic references related to constant pool resolution and method returned data. It is also used to store a reference to the exception table(part of method metadata) which has all the information related to catch block in case of exceptions.

      Note: Stack area is not a shared resource.

      4. PC Registers: JVM supports multiple threads at the same time and each thread has separate PC registers. These registers are used to store address of the currently executed JVM instruction. After completion of current instruction, PC register is going to be updated with next instruction.

      5. Native method stack: This stack is used to hold the information related to native methods written in C, C++ and Assembly.

   3. Execution engine: The execution engine is responsible for executing the bytecode that is loaded into the JVM. It communicates with various runtime data memories of JVM during the execution. Once the program is finished executing, the memory in the runtime data area will be released.

      It contains three main components for executing the class files.

      1. Interpreter: The interpreter reads and executes the bytecode instructions line by line to convert into respective machine language instructions. The main advantage of interpreter is that it is very quick to load and execute the code in a faster pace. But whenever it executes the same code blocks again and again, the interpreter executes repeatedly. So the interpreter cannot be optimized the runtime in case of repeated code execution.

      2. JIT compiler: Just-In-Time Compiler(JIT Compiler) is introduced to overcome the disadvantages of interpreter, especially with repeated code execution. JIT compiler can remember the repeated code block segments and they will stored as native code in the cache. Whenever JIT compiler reads the same code block again, it will use the native code stored in the cache.

      JIT compiler has further divided into the following components,

      3. Intermediate Code Generator: It generates intermediate code.

      4. Code Optimizer: It optimizes the intermediate code for better performance.

      5. Target Code Generator: It converts intermediate code into native machine code.

      6. Profiler: This is used to identify Hotspots(i.e, repeatedly executing methods) and replace hotspots with respective native code.

      7. Garbage Collector: Garbage Collector(GC) is responsible to collect and remove unreferenced objects from the heap area. This memory management feature is used to reclaim the unused memory and makes free space for newer objects. This happens in two phases:

         1. Mark: In this step, GC identifies the unused objects in memory
         2. Sweep: As part of this step, GC removes the objects identified in the previous phase.

      **Note:**Modern JVMs use more sophisticated algorithms (e.g., generational GC, parallel GC, G1GC) to optimize garbage collection.

   4. Java Native Interface (JNI) : JNI is used as a bridge between java method calls and native libraries written in C, C++ etc. Sometimes it is required to invoke native code for specific underlined hardeware.

   5. Native Method Libraries : These are collection of native libraries(C/C++/Assembly) which are required by execution engine. These libraries loaded through JNI and represented in the form of .dll or .so files.

   ⬆ Back to Top

4. What are the main features of Java

   Java has many important features which makes it unique among the popular programming languages. Some of those features are:

   1. Simple: Java is a simple programming language and easy to understand without any complexities unlike in the prior programming languages. Some of the reasons for simplicity are: 1. It is based on C++ which makes it easy for new developers to learn it quickly. 2. Java doens't support pointers(unlike C or C++) considering its complexity and security vulnerabilities. Also, operator overloading doesn't exist in Java. 3. There is no need to remove unreferenced objects because it will be taken care by Automatic Garbage Collection.

   2. Object-oriented: Java is an Object Oriented programming(OOPS) language, which means everything in Java is represented with different types of classes and objects. This OOPS is a methodology that simplifies software development and maintenance by following the below features.

      1. Abstraction
      2. Encapsulation
      3. Inheritance
      4. Polymorphism

   3. Portable: Java is portable because the bytecode generated on one machine can be taken to any platform for the execution.

   4. Platform Independent: The java compiler converts the source code to bytecode and then JVM executes the bytecode to produce the output. If you compile a java program on specific operating system(let's say Windows), it can run on any other platform(Windows, Linux or Mac) with that platform specific JVM. This is the reason why we call Java as a platform-independent language.

   5. Robust: Java is robust with many safe guards to ensure reliable code. It has the below safe guards,

      1. It is capable of handling unexpected termination of a program through exception handling feature.
      2. It provides strong memory management through Garbage Collector from JVM, which collects all the unused variables and objects to free up the memory space. Whereas in prior programming languages, programmers are solely responsible for allocating and deallocating memory spaces.

   6. Secured: Java is extremely safe due to various features listed below,

      1. There are no explicit pointers. So you cannot access out-of-bound array. If you still try to access an array, it will show an ArrayIndexOutOfBound Exception. So it is impossible to exploit in Java with security flaws like stack corruption or buffer overflow.
      2. The programs runs in an secured environment(JVM) that is independent of operating system(OS).
      3. Java has bytecode verifier that checks the code blocks for any illegal code that violates the access right to objects.

   7. Distributed: Java supports the creation of distributed applications by using Remote Method Invocation(RMI) and Enterprise Java Beans. The java programs are easily distributed on one or more systems through internet connection.

   8. Multi-threaded: Java supports multithreading feature, which allows concurrent execution of several parts of a program for maximum utilization of the CPU. This is possible through multiple threads running the program simultaneously.

   9. Compiled and Interpreted: It provides both compilation and interpretation of programs. The programs are compiled by compiler first and the generated bytecode is going to be interpreted.

   10. High performance: Java bytecode is close to native code, so it runs more quickly than other conventionally interpreted programming languages. Ofcourse, it is not as fast as compiled languages like C or C++. JVM also uses JIT compiler which enables high performance through below features.

   11. Method inlining

   12. Dead code elimination

   13. Null check elimination

   14. Constant folding

   ⬆ Back to Top

5. What is public static void main?

   The main() method acts as a starting point for JVM to start the execution of a Java program. i.e, JVM doesn't execute the code if there is no main method in the code. The signature of main method should follow specific pattern for the JVM to recognize it as a entry point. Since it is an important method of Java, you need to have proper understanding of its signature in detail.

   The signature of main method for displaying "Hello World" looks like below,

   public static void main(String[] args) {
        System.out.println("Hello World");
   }
   

   When java.exe parses the command line, it generates a new String array and invokes the main() method. Let's describe each word in the statement,

   1. public: The public access modifier is accessible everywhere and it enables JVM can invoke it from outside the class as it is not present in the current class. Otherwise, you will receive an error saying "Main method not found in class".

   2. static: This static keyword is used to make main() method as a class related method so that JVM can invoke it without instantiating the class. It is also helpful to avoid unnecessary memory usage with object just for calling main method.

   3. void: The void keyword is used to specify that a method doesn’t return anything. Since main() method doesn't return anything, its return type is void. Once the main method terminates, the java program terminates as well.

   4. main: The "main" method name is an identifier that the JVM looks for as the starting point of the Java program.

   5. String[] args: This is an array of strings which stores arguments passed by command line while starting a program.

   Note: You can create any number of main methods through overloading features. i.e, Multiple main methods can be created with different parameters.

   ⬆ Back to Top

6. What is string constant pool

   String constant pool is a special storage space inside the heap memory area where string literals are stored. It is also known as String pool or String Intern Pool. This is privately maintained by String class and it is empty by default. Whenever you create a new string object, JVM checks for presence of string object in the string pool. If the string value is already present, the same object reference is shared with the variable, else a new string is created in the pool with the variable reference stored in stack area.

   ⬆ Back to Top

7. Why strings are immutable

   In Java, the String class is immutable, meaning once a String object is created, its value cannot be changed. If you try to modify it (for example, by concatenating text), Java creates a new String object instead of altering the original one. Due to this behavior, the internal state of a string remains the same throughout the execution of the program.

   One major reason for this is security. Strings are used for sensitive data like file paths, database URLs, and class names. If strings were mutable, their values could be changed after validation, leading to security risks. Immutability ensures the value remains safe once created.

   Another reason is the String Constant Pool, where identical string literals share the same memory. This saves memory and improves performance. Since strings are immutable, multiple references can safely point to the same object without affecting each other.

   Immutability also provides thread safety. Multiple threads can use the same String object without synchronization because its value cannot change. Additionally, strings are commonly used as keys in hash-based collections, and immutability ensures their hash codes remain consistent.

   In summary, String is immutable in Java for security, memory efficiency, thread safety, and reliable behavior in collections.

   ⬆ Back to Top

8. What is the difference between StringBuffer and StringBuilder

   String is an immutable class to represent sequence of characters. Java also provided mutable version of String class through StringBuffer and StringBuilder. Even though both these classes are mutable, there are many differences between StringBuffer and StringBuilder.

   Some of the major differences in a tabular form:

   StringBuffer	StringBuilder
   StringBuffer was introduced in Java 1.0 version	StringBuilder was introduced in Java 1.5 version
   StringBuffer is synchronized(thread safe). That means two or more threads cannot call the methods of StringBuffer simultaneously	StringBuilder is non-synchronized(not thread safe). That means two or more threads can call the methods of StringBuilder simultaneously.
   Due to Synchronization, StringBuffer is slower than StringBuilder	StringBuilder is faster than StringBuffer because there won't be any preliminary checks for multiple threads

   ⬆ Back to Top

9. What is the importance of hashCode() and equals() methods

   Since both equals() and hashCode() methods are available in Object class(i.e, Java.lang.object), every java class gets the default implementation of equals and hashCode methods. These methods work together to verify if two objects have the same value or not.

   1. equals: The equals() method is used to compare equality(i.e, logical equality) of two Objects. By default their implementation compares the identities(i.e, memory addresses) of the object. The Object class defined equals() method as follows,

   public boolean equals(Object obj) {
       return (this == obj);
   }
   

   There are some rules need to be followed to use equals method:

   1. Reflexive: For any object x, x.equals(x) should return true.
   2. Symmetric: For any two objects x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
   3. Transitive: For multiple objects x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
   4. Consistent: For any two objects x and y, multiple invocations of x.equals(y) should return same result(true or false), unless any of the object properties is modified that is being used in the equals() method implementation.
   5. Non-null comparison: For any non-null object x, x.equals(null) should return false.

   2. hashCode: The hashCode() method returns the integer hash code value of the object, used by hash-based collections. This method determines bucket placement. It must be overridden in every class which overrides equals() method. The general contract of hashCode is:

   1. While execution of the application, the multiple invocations of hashCode() on the object should return the same integer value, unless the object property used in the equals() method is being modified.
   2. During the multiple executions of the application, the object's hashCode can change.
   3. If two objects are equal based on equals() method, then their object's hash code must be same.
   4. If two objects are unequal based on equals() method, their hash code value may or may not be equal.

   Together, the implementation of equals() and hashCode() should follow these rules.

   1. If x.equals(y) is true, then x.hashCode() === y.hashCode() should always be true.
   2. If x.hashCode() === y.hashCode() is true, then it doesn't required to be x.equals(y) always true.

   Note: equals() defines logical equality, and hashCode() ensures equal objects are stored and retrieved correctly in hash-based collections.

   ⬆ Back to Top

10. What is the difference between checked and unchecked expceptions

    An exception is an event that interrupts the normal flow the program execution. There are two types of exceptions,

    1. Checked exceptions
    2. Unchecked exceptions

    The hierarchical structure of exceptions is categorized as shown below,

    

    The exceptions which are checked at compile time are known as checked exceptions. If some code inside a method throws this checked exception, then either you need to handle(or caught) the exception using try/catch block or declare in the method signature using thows keyword.

    Some of the common checked exceptions are,

    3. IOException
    4. FileNotFoundException
    5. ClassNotFoundException
    6. InterruptedException
    7. SQLException
    8. ParseException

    For example, the following class has two methods which throws checked(FileNotFoundException) exceptions from FileInputStream constructor. This is due to accessing input file which doesn't exist. You can handle them either using try/catch block or declaring thows keyword in the method signature.

        import java.io.*;
    
        class MyCheckedExceptions {
    
            private void methodWithTryCatch() {
                    File file = new File("non_existing_file.txt");
                    try {
                        FileInputStream stream = new FileInputStream(file);
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
            }
    
            private void methodWithThrows() throws FileNotFoundException {
                    File file = new File("non_existing_file.txt");
                    FileInputStream stream = new FileInputStream(file);
            }
    
        }
    

    Whereas the exceptions which are not checked at compile time are known as unchecked exceptions. All the exceptions under Error and RuntimeException comes under unchecked exceptions.

    Some of the common unchecked exceptions are,

    9. NullPointerException
    10. ArrayIndexOutOfBoundsException
    11. ArithmeticException
    12. NumberFormatException
    13. IllegalThreadStateException

    For example, the following method doesn't have any errors during compile time. But it will throw ArithmeticException during runtime because of division by zero.

    class MyUncheckedException {
    
        private void divideByZero() {
    	    int a = 1;
    	    int b = 0;
    	    int result = a / b;
        }
    
    }
    

    ⬆ Back to Top

11. What are wrapper classes

    Wrapper classes provides the mechanism to convert primitive types into object types and vice versa. Since Java is an object-oriented programming language, and many APIs and libraries in Java require objects instead primitive types. For example, data structures in collection framework, utility classes from java.utils.*,cloning process, Serialization, Synchronization etc require object type.

    The following table represent primitives and their respective wrapper classes.

    Primitive data type	Wrapper class
    byte	Byte
    short	Short
    int	Integer
    float	Float
    double	Double
    long	Long
    boolean	Boolean
    char	Character

    You can use .valueOf methods from wrapper classes to convert primitive to object type, and the same way wrapper class methods like intValue, doubleValue etc used to convert wrapper class to primitive type. But this manual process can be automated.

    1. autoboxing

    The automatic conversion of primitive to object(corresponding wrapper class) is known as autoboxing. The following example demonstrate how the conversion works,

    public class AutoboxingDemo{
        public static void main(String args[]){
            int num = 10;
            Integer x = Integer.valueOf(num); // Converting primitive int into Integer explicitly
            Integer y = num; // Autoboxing without explicit conversion
    
            System.out.println("x = "+ x + " y " + y);
        }
    }
    

    2. unboxing The automatic conversion of wrapper class to primitive is known as unboxing. The following example demonstrate both manual and automatic conversion,

    public class UnboxingDemo{
       public static void main(String args[]){
           Integer num = new Integer(3);
           int x = num.intValue(); //Converting Integer to int explicitly
           int y = num; //Unboxing without manual conversion
    
           System.out.println("x ="+ x + "y = "+y);
       }
    }
    

    Note: These autoboxing and unboxing features are available from JDK1.5 version onwards.

    ⬆ Back to Top

12. Why java is not pure object oriented language

    Java is not a fully object-oriented programming language because of two main reasons.

    1. It supports primitive data types like int, byte, long, short, etc., which are not objects. Even though you can convert primitive data types to objects using wrapper classes, it does not make Java a pure object-oriented language. Because these objects are not originally associated with Java and internally it uses operations like Unboxing and Autoboxing. That means even you use wrapper classes, under the hood it uses primitive types for the calculation.

    2. Both static variables and methods can be accessed without using an object. Instead, they are associated with classes, which is against to the object-oriented principle where everything should be an object.

    ⬆ Back to Top

13. What is the difference between abstract class and interface

    Both Abstract class and interface are used to define contracts in object-oriented programming. But there are some key differences between them as shown below,

    Abstract class	Interface
    The abstract keyword is used to declare abstract class and it can be extended using extends keyword	The interface keyword is used to declare interface and it can extend another interface only.
    The abstract class contains abstract and non-abstract methods	Interface can have abstract methods only. But it is possible to have default and static methods from Java8 onwards
    It supports final, non-final, static and non-static variables	It supports only final and static variables.
    It doens't support multiple inheritance	Interface supports multiple inheritance
    It can have access modifiers such as public, protected, and private for their methods and properties	It can only have public access

    Note: Both Abstract class and interfaces cannot be instantiated.

    ⬆ Back to Top

14. What are marker interfaces

    Marker interfaces are interfaces that don't have any fields, methods, or constants inside of it. They are also known as empty interfaces or tag interfaces. Examples of marker interface are Serializable, Cloneable and Remote interface. The purpose of marker interfaces are to provide run-time type information about an object to JVM and Compiler. They are mainly used in API development and in frameworks like Spring to provide additional information to the class.

    Some of the commonly used built-in marker interfaces are:

    1. Cloneable: It is available in java.lang package. If we try to clone an object that doesn’t implement this marker interface, the JVM throws a CloneNotSupportedException. i.e, This marker interface is used as a signal/indicator to the JVM that it is legal to call the Object.clone() method.
    2. Serializable: It is available in java.io package. When we try to write an object to output stream using ObjectOutputStream.writeObject() method without implementing this marker interface, JVM throws an exception named NotSerializableException.
    3. Remote: It is available in java.rmi package. A remote object can be accessed from another machine if and only if the class has implemented this marker interface. Otherwise, it is going to throw exception named RemoteException.

    For example, the cloneable marker interface looks like below,

    public interface Cloneable {
       // nothing here
    }
    

    and the following student class implements Cloneable interface to make a copy of student's object.

    import java.lang.*;
    
    class Student implements cloneable {
    
        String name = null;
        int age = 0;
    
        Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        public static void main(String[] args) {
    
            Student s1 = new Student("Sudheer", 30);
            //Create clone of s1 object
            try {
                Student s2 = s1.clone();
            } catch (Exception e) {
                System.out.println(s2.toString());
            }
        }
    }
    
    

    There are also alternatives for marker interfaces.

    4. Internal flags: They can be used in place of marker interface to indicate any specific operation.
    5. Annotations: They are used as tags to represent the metadata attached to classes, interfaces, or methods to indicate additional information required by JVM.

    ⬆ Back to Top

15. What are collections in Java?

    Collections in Java is a unified framework that provides architecture for storing and manipulating a group of objects.

    The java.util.* package contains the following classes and interfaces for Collections framework.

    

    ⬆ Back to Top

16. What are the differences between arraylist and vector?

    Both Vector and ArrayList use dynamically resizable array as their internal data structure and implement the List interface. But there are couple of differences between them as listed below,

    ArrayList	Vector
    This data structure is part of Collection framework, introduced in JDK 1.2	This is a legacy class
    The capacity increment of ArrayList is 50% if the number of elements exceeds the current size	The capacity increment of Vector is 100% if the number of elements exceeds the current size
    It is not synchronized by default. That means multiple threads can access it concurrently.	It is synchronized by default. That means only one thread can access it at a time.
    It is quite fast because it is not synchronized	It is quite slow due to synchronization
    ArrayList uses the Iterator interface to traverse over the elements.	Vector uses both the Iterator and Enumeration interfaces to traverse over the elements.

    ⬆ Back to Top

17. What is finalize method? How do you override it?

    The finalize() is a method from the Object class used to perform cleanup activity before destroying any object. The method is invoked by garbage collector for cleanup activities like closing the resources associated with an object(database connection or network connection). This process is known as finalization and it helps JVM for in-memory optimization.

    It is a protected method of Object class with syntax as shown below,

    protected void finalize() throws Throwable{}
    

    Since Object is the superclass of all java classes, the finalize method is available for every java class. That's why garbage collector can call the finalize() method on any java object.

    This method has empty implementation inside Object class. If your class has clean-up activities, you need to override this method. The following example demonstrate how to override the finalize method and call the method explicitly.

    import java.lang.*;
    
    public class finalizeDemo {
    
        protected void finalize() throws Throwable {
                try {
    
                    System.out.println("Inside finalize() method of finalizeDemo class");
                }
                catch (Throwable e) {
    
                    throw e;
                }
                finally {
    
                    System.out.println("Calling finalize method of the Object(super) class");
    
                    super.finalize();
                }
        }
    
        public static void main(String[] args) throws Throwable {
            finalizeDemo fd = new finalizeDemo();
            fd.finalize();
        }
    }
    

    The statement super.finalize() is called inside finally block to ensure its execution even in the case of exceptions.

    Note: The garbage collector invokes the finalize() method only once on any object.

    ⬆ Back to Top

18. What Is the Difference Between the Comparable and Comparator Interfaces

    Java provides Comparable and Comparator interfaces for sorting the collection of objects, but they serve different purposes and are used in different scenarios.

    Comparable: The Comparable interface is capable of comparing an object with another object of same type. The class which needs to compare its instances has to implement java.lang.Comparable interface. It can be used to provide single way of sorting. That means that the objects can be sorted based on a single data member. For example, Employee object can be sorted based on single attributes like id, name, age etc.

    If the class implements Comparable interface, it knows how to sort the objects because the same class itself has implemented compareTo method. This type of sorting is called default or natural sorting. The class can compare its object by overriding compareTo method with syntax as shown below,

    class T implements Comparable<T> {
        @Override
        public int compareTo(T t) {
            // comparison logic goes here
        }
    }
    

    For example, group of employees sorted based on their name attribute using Comparable interfaces as follows

    import java.util.*;
    
    class Employee implements Comparable<Employee> {
        private final String id;
        private final String name;
        private final int age;
        
        public Employee(String id, String name, int age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
        
        @Override
        public int compareTo(final Employee employee) {
            return this.name.compareTo(employee.name);
        }
        
        public String getId() { return this.id; }
        
        public String getName() { return this.name; }
        
        public int getAge() { return this.age; }
        
        @Override
        public String toString() {
            return String.format("ID: %s | Name: %s | Age: %d", id, name, age);
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            List<Employee> employees = new ArrayList<>();
    
            employees.add(new Employee("3", "John", 32));
            employees.add(new Employee("1", "James", 27));
            employees.add(new Employee("2", "Jackson", 22));
            
            Collections.sort(employees);
    
            employees.forEach(employee -> 
                                System.out.println(employee.toString()));
        }
    }
    

    Comparator:

    The comparator is a functional interface used to sort objects and it provides multiple sorting sequence in which objects sorted based on multiple data members. This interface is available as part of java.util package. For example, Employee object can be sorted based on multiple attributes like id, name, age etc.

    The comparator is used for custom ordering where the class is not aware about the sorting logic. The comparator can be created using a lambda expression that accept two objects of given type and return an integer value(i.e, 1, 0, -1) based on ordering with syntax as shown below,

     Comparator<T> comparator = (T t1, T t2) -> { 
        //comparison logic 
     }
    

    You can create multiple separate classes (which implement Comparator interface) to compare by different members.The Comparator provides the compare() method which can be overridden to customize the comparison logic. For example, group of employees sorted based on id and age data members even though Employee class overridden the compareTo method.

    public static void sortById(List<Employee> employees) {
        Comparator<Employee> idComparator = (Employee e1, Employee e2) -> {
            return e1.getId().compareTo(e2.getId());
        };
        
        employees.sort(idComparator);
    }
    
    public static void sortByAge(List<Employee> employees) {
        Comparator<Employee> ageComparator = (Employee e1, Employee e2) -> {
            return e1.getAge() - e2.getAge();
        };
        
        employees.sort(ageComparator);
    }
    

    In the above example, idComparator and ageComparator have been created to perform custom sorting. These comparators needs to be passed as an argument to sort method.

    Note: It is preferred to use lambda expression to create Comparator because it is a functional interface(exactly one abstract method).

    ⬆ Back to Top

19. What Is an inner class

An inner class is a class that is defined within another class. Inner classes are used to logically group classes that are only used in one place, increase encapsulation, and make code more readable and maintainable. Java supports four types of inner classes:

1. Member Inner Class (Non-static nested class): A class defined inside another class without the static modifier. It has access to all members of the outer class, including private members.

class Outer {
    private int data = 30;
    
    class Inner {
        void display() {
            System.out.println("Data: " + data);
        }
    }
    
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

2. Static Nested Class: A static class defined inside another class. It can only access static members of the outer class.

class Outer {
    static int data = 30;
    
    static class StaticNested {
        void display() {
            System.out.println("Data: " + data);
        }
    }
    
    public static void main(String[] args) {
        Outer.StaticNested nested = new Outer.StaticNested();
        nested.display();
    }
}

3. Local Inner Class: A class defined within a method. It can access local variables that are final or effectively final.

class Outer {
    void display() {
        final int num = 23;
        
        class LocalInner {
            void print() {
                System.out.println("Number: " + num);
            }
        }
        
        LocalInner inner = new LocalInner();
        inner.print();
    }
}

4. Anonymous Inner Class: A class without a name, used to instantiate objects with certain extras such as overriding methods.

abstract class Animal {
    abstract void sound();
}

class Test {
    public static void main(String[] args) {
        Animal dog = new Animal() {
            void sound() {
                System.out.println("Bark");
            }
        };
        dog.sound();
    }
}

⬆ Back to Top

20. What is the difference between final, finally, and finalize() in Java?

The terms final, finally, and finalize() in Java look similar but serve completely different purposes.

1. final → It is a modifier used for variables, methods, and classes.

   • A final variable cannot be reassigned once initialized.
   • A final method cannot be overridden in subclasses.
   • A final class cannot be extended.

2. finally → It is a block used in exception handling to execute important code such as closing files, releasing connections, etc.

   • The finally block executes regardless of whether an exception occurs or not.

3. finalize() → It is a method defined in the Object class that the Garbage Collector calls before destroying an object.

   • It is rarely used now because garbage collection timing is unpredictable.

Example:

public class FinalExample {
    final int VALUE = 100;

    public final void display() {
        System.out.println("Final method");
    }

    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
        } finally {
            System.out.println("Inside finally block");
        }
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalize method called");
    }
}

⬆ Back to Top

21. What is the difference between '==' and equals() method?

    Both == and .equals() methods are used to compare objects, but they work in different ways:

    1. == (Reference comparison): The == operator compares the memory addresses (references) of two objects. It returns true if both references point to the same object in memory.

    2. .equals() (Content comparison): The .equals() method compares the actual content or values of two objects. By default, it behaves like ==, but it can be overridden to provide custom comparison logic.

    public class ComparisonExample {
        public static void main(String[] args) {
            String s1 = new String("Hello");
            String s2 = new String("Hello");
            String s3 = s1;
            
            // == compares references
            System.out.println(s1 == s2);      // false (different objects)
            System.out.println(s1 == s3);      // true (same reference)
            
            // equals() compares content
            System.out.println(s1.equals(s2)); // true (same content)
            System.out.println(s1.equals(s3)); // true (same content)
        }
    }
    

    == Operator	equals() Method
    Compares object references	Compares object content
    Cannot be overridden	Can be overridden
    Works with primitives and objects	Works only with objects
    Returns true if same memory location	Returns true if content is same

    ⬆ Back to Top

22. What is method overloading and method overriding?

    Method overloading and method overriding are two important concepts in Java that enable polymorphism.

    Method Overloading (Compile-time Polymorphism): Method overloading occurs when multiple methods in the same class have the same name but different parameters (different number, type, or order of parameters). The return type can be the same or different.

    class Calculator {
        // Method with two int parameters
        int add(int a, int b) {
            return a + b;
        }
        
        // Overloaded method with three int parameters
        int add(int a, int b, int c) {
            return a + b + c;
        }
        
        // Overloaded method with double parameters
        double add(double a, double b) {
            return a + b;
        }
    }
    

    Method Overriding (Runtime Polymorphism): Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its parent class. The method must have the same name, return type, and parameters.

    class Animal {
        void sound() {
            System.out.println("Animal makes a sound");
        }
    }
    
    class Dog extends Animal {
        @Override
        void sound() {
            System.out.println("Dog barks");
        }
    }
    
    class Cat extends Animal {
        @Override
        void sound() {
            System.out.println("Cat meows");
        }
    }
    

    Method Overloading	Method Overriding
    Same method name, different parameters	Same method name, same parameters
    Occurs within the same class	Occurs between parent and child class
    Compile-time polymorphism	Runtime polymorphism
    Return type can be different	Return type must be same or covariant
    Access modifier can be any	Cannot reduce access modifier

    ⬆ Back to Top

23. What is the difference between HashMap and Hashtable?

    Both HashMap and Hashtable are used to store key-value pairs in Java, but they have several important differences:

    HashMap	Hashtable
    Not synchronized (not thread-safe)	Synchronized (thread-safe)
    Allows one null key and multiple null values	Does not allow null keys or values
    Introduced in Java 1.2	Legacy class from Java 1.0
    Faster due to no synchronization	Slower due to synchronization overhead
    Iterator is fail-fast	Enumerator is not fail-fast
    Extends AbstractMap class	Extends Dictionary class
    Preferred for single-threaded applications	Can be used in multi-threaded applications

    import java.util.*;
    
    public class MapComparison {
        public static void main(String[] args) {
            // HashMap example
            HashMap<String, Integer> hashMap = new HashMap<>();
            hashMap.put("One", 1);
            hashMap.put(null, 0);        // Allows null key
            hashMap.put("Two", null);    // Allows null value
            
            // Hashtable example
            Hashtable<String, Integer> hashtable = new Hashtable<>();
            hashtable.put("One", 1);
            // hashtable.put(null, 0);   // Throws NullPointerException
            // hashtable.put("Two", null); // Throws NullPointerException
        }
    }
    

    Note: For thread-safe operations, prefer ConcurrentHashMap over Hashtable as it provides better performance through segment-level locking.

    ⬆ Back to Top

24. What is the difference between ArrayList and LinkedList?

    Both ArrayList and LinkedList implement the List interface but differ in their internal implementation and performance characteristics.

    ArrayList	LinkedList
    Uses dynamic array internally	Uses doubly linked list internally
    Better for storing and accessing data (O(1) for get)	Better for manipulating data (O(1) for add/remove at ends)
    Slower manipulation as shifting is required	Faster manipulation, no shifting needed
    Implements only List interface	Implements List and Deque interfaces
    More memory efficient	More memory overhead (stores prev/next references)
    Good for random access	Good for sequential access

    import java.util.*;
    
    public class ListComparison {
        public static void main(String[] args) {
            // ArrayList - better for random access
            ArrayList<String> arrayList = new ArrayList<>();
            arrayList.add("A");
            arrayList.add("B");
            arrayList.get(0);  // O(1) - fast random access
            
            // LinkedList - better for frequent insertions/deletions
            LinkedList<String> linkedList = new LinkedList<>();
            linkedList.add("A");
            linkedList.addFirst("B");  // O(1) - fast insertion at beginning
            linkedList.removeLast();   // O(1) - fast removal at end
        }
    }
    

    When to use:

    • Use ArrayList when you need frequent access to elements by index
    • Use LinkedList when you need frequent insertions/deletions, especially at the beginning or middle of the list

    ⬆ Back to Top

25. What is Java Reflection API?

    Java Reflection API is a powerful feature that allows programs to examine and modify the behavior of classes, interfaces, methods, and fields at runtime. It is part of the java.lang.reflect package.

    Key capabilities of Reflection:

    1. Examine class properties at runtime
    2. Create objects dynamically
    3. Invoke methods at runtime
    4. Access and modify private fields
    5. Get information about constructors, methods, and fields

    import java.lang.reflect.*;
    
    class Person {
        private String name;
        public int age;
        
        public Person() {}
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        private void privateMethod() {
            System.out.println("Private method called");
        }
        
        public void display() {
            System.out.println("Name: " + name + ", Age: " + age);
        }
    }
    
    public class ReflectionDemo {
        public static void main(String[] args) throws Exception {
            // Get Class object
            Class<?> clazz = Person.class;
            
            // Get class name
            System.out.println("Class: " + clazz.getName());
            
            // Get all declared methods
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println("Method: " + method.getName());
            }
            
            // Create instance dynamically
            Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
            Person person = (Person) constructor.newInstance("John", 25);
            
            // Access private field
            Field nameField = clazz.getDeclaredField("name");
            nameField.setAccessible(true);
            nameField.set(person, "Jane");
            
            // Invoke method
            Method displayMethod = clazz.getMethod("display");
            displayMethod.invoke(person);
        }
    }
    

    Use cases: Frameworks like Spring, Hibernate, JUnit use Reflection extensively for dependency injection, ORM mapping, and test execution.

    ⬆ Back to Top

26. What are the different types of memory areas allocated by JVM?

    JVM allocates memory in different areas for efficient program execution. The main memory areas are:

    1. Method Area (Metaspace):

       • Stores class-level data like class structures, method data, and runtime constant pool
       • Shared among all threads
       • Created during JVM startup

    2. Heap Area:

       • Stores all objects and their instance variables
       • Shared among all threads
       • Managed by Garbage Collector
       • Divided into Young Generation (Eden, Survivor spaces) and Old Generation

    3. Stack Area:

       • Each thread has its own stack
       • Stores local variables, method calls, and partial results
       • Contains stack frames for each method invocation
       • Memory is automatically allocated/deallocated

    4. PC (Program Counter) Registers:

       • Each thread has its own PC register
       • Stores address of currently executing JVM instruction
       • Updated after each instruction execution

    5. Native Method Stack:

       • Contains native method information
       • Each thread has its own native method stack
       • Used for methods written in languages other than Java (C, C++)

    JVM Memory Structure:
    ┌─────────────────────────────────────────────┐
    │              Method Area (Metaspace)         │
    │  (Class data, Method data, Constant pool)   │
    ├─────────────────────────────────────────────┤
    │                  Heap Area                   │
    │  ┌─────────────────┬─────────────────────┐  │
    │  │ Young Generation│   Old Generation    │  │
    │  │ (Eden,Survivor) │                     │  │
    │  └─────────────────┴─────────────────────┘  │
    ├─────────────────────────────────────────────┤
    │  Stack │  Stack  │  Stack  │ ... (per thread)│
    ├─────────────────────────────────────────────┤
    │  PC Reg│  PC Reg │  PC Reg │ ... (per thread)│
    ├─────────────────────────────────────────────┤
    │  Native│ Native  │ Native  │ ... (per thread)│
    └─────────────────────────────────────────────┘
    

    ⬆ Back to Top

27. What is the difference between throw and throws?

    Both throw and throws are used in exception handling but serve different purposes.

    throw:

    • Used to explicitly throw an exception
    • Used inside a method body
    • Can throw only one exception at a time
    • Followed by an exception instance

    throws:

    • Used to declare exceptions that a method might throw
    • Used in method signature
    • Can declare multiple exceptions
    • Followed by exception class names

    import java.io.*;
    
    public class ThrowVsThrows {
        
        // Using throws - declares that method may throw an exception
        public void readFile(String filename) throws FileNotFoundException, IOException {
            FileReader file = new FileReader(filename);
            BufferedReader reader = new BufferedReader(file);
            String line = reader.readLine();
            reader.close();
        }
        
        // Using throw - explicitly throws an exception
        public void validateAge(int age) {
            if (age < 0) {
                throw new IllegalArgumentException("Age cannot be negative");
            }
            if (age < 18) {
                throw new ArithmeticException("Not eligible to vote");
            }
            System.out.println("Eligible to vote");
        }
        
        // Combining throw and throws
        public void processData(String data) throws CustomException {
            if (data == null) {
                throw new CustomException("Data cannot be null");
            }
            // Process data
        }
    }
    
    class CustomException extends Exception {
        public CustomException(String message) {
            super(message);
        }
    }
    

    throw	throws
    Used to throw an exception	Used to declare an exception
    Inside method body	In method signature
    Cannot throw multiple exceptions	Can declare multiple exceptions
    Followed by instance	Followed by class name
    Checked exceptions must be caught	Propagates exception to caller

    ⬆ Back to Top

28. What is a singleton class and how to create one?

    A Singleton class is a design pattern that ensures only one instance of a class is created throughout the application lifecycle. It provides a global point of access to that instance.

    Key characteristics:

    • Private constructor to prevent direct instantiation
    • Static method to get the single instance
    • Static variable to hold the single instance

    Different ways to create Singleton:

    1. Eager Initialization:

    public class EagerSingleton {
        private static final EagerSingleton instance = new EagerSingleton();
        
        private EagerSingleton() {}
        
        public static EagerSingleton getInstance() {
            return instance;
        }
    }
    

    2. Lazy Initialization:

    public class LazySingleton {
        private static LazySingleton instance;
        
        private LazySingleton() {}
        
        public static LazySingleton getInstance() {
            if (instance == null) {
                instance = new LazySingleton();
            }
            return instance;
        }
    }
    

    3. Thread-Safe Singleton (Double-Checked Locking):

    public class ThreadSafeSingleton {
        private static volatile ThreadSafeSingleton instance;
        
        private ThreadSafeSingleton() {}
        
        public static ThreadSafeSingleton getInstance() {
            if (instance == null) {
                synchronized (ThreadSafeSingleton.class) {
                    if (instance == null) {
                        instance = new ThreadSafeSingleton();
                    }
                }
            }
            return instance;
        }
    }
    

    4. Bill Pugh Singleton (Best Practice):

    public class BillPughSingleton {
        private BillPughSingleton() {}
        
        private static class SingletonHelper {
            private static final BillPughSingleton INSTANCE = new BillPughSingleton();
        }
        
        public static BillPughSingleton getInstance() {
            return SingletonHelper.INSTANCE;
        }
    }
    

    ⬆ Back to Top

29. What are Java 8 Stream API features?

    Java 8 Stream API provides a functional approach to process collections of objects. Streams support sequential and parallel operations on data.

    Key Features:

    1. Lazy Evaluation: Intermediate operations are not executed until a terminal operation is invoked
    2. Pipelining: Operations can be chained together
    3. Internal Iteration: Stream handles iteration internally
    4. Parallel Processing: Easy parallel execution with parallelStream()

    Common Stream Operations:

    import java.util.*;
    import java.util.stream.*;
    
    public class StreamDemo {
        public static void main(String[] args) {
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
            
            // filter - filters elements based on condition
            List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
            // Result: [2, 4, 6, 8, 10]
            
            // map - transforms elements
            List<Integer> squares = numbers.stream()
                .map(n -> n * n)
                .collect(Collectors.toList());
            // Result: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
            
            // reduce - combines elements
            int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);
            // Result: 55
            
            // sorted - sorts elements
            List<Integer> sorted = numbers.stream()
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
            
            // distinct - removes duplicates
            List<Integer> unique = Arrays.asList(1, 1, 2, 2, 3).stream()
                .distinct()
                .collect(Collectors.toList());
            // Result: [1, 2, 3]
            
            // limit and skip
            List<Integer> limited = numbers.stream()
                .skip(2)
                .limit(5)
                .collect(Collectors.toList());
            // Result: [3, 4, 5, 6, 7]
            
            // anyMatch, allMatch, noneMatch
            boolean hasEven = numbers.stream().anyMatch(n -> n % 2 == 0);
            boolean allPositive = numbers.stream().allMatch(n -> n > 0);
            
            // findFirst, findAny
            Optional<Integer> first = numbers.stream().findFirst();
            
            // count
            long count = numbers.stream().filter(n -> n > 5).count();
            
            // forEach
            numbers.stream().forEach(System.out::println);
        }
    }
    

    ⬆ Back to Top

30. What is the difference between fail-fast and fail-safe iterators?

    Iterators in Java can be categorized as fail-fast or fail-safe based on their behavior when the underlying collection is modified during iteration.

    Fail-Fast Iterator:

    • Throws ConcurrentModificationException if the collection is modified during iteration
    • Works on the original collection
    • Examples: ArrayList, HashMap, HashSet iterators
    • Uses modCount to detect modifications

    import java.util.*;
    
    public class FailFastExample {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("A");
            list.add("B");
            list.add("C");
            
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String element = iterator.next();
                if (element.equals("B")) {
                    list.remove(element); // Throws ConcurrentModificationException
                }
            }
        }
    }
    

    Fail-Safe Iterator:

    • Does not throw exception if collection is modified during iteration
    • Works on a clone/copy of the collection
    • Examples: CopyOnWriteArrayList, ConcurrentHashMap iterators
    • More memory overhead due to copying

    import java.util.concurrent.*;
    import java.util.*;
    
    public class FailSafeExample {
        public static void main(String[] args) {
            CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
            list.add("A");
            list.add("B");
            list.add("C");
            
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String element = iterator.next();
                if (element.equals("B")) {
                    list.remove(element); // No exception thrown
                }
            }
            System.out.println(list); // [A, C]
        }
    }
    

    Fail-Fast	Fail-Safe
    Throws ConcurrentModificationException	No exception thrown
    Works on original collection	Works on copy of collection
    Less memory overhead	More memory overhead
    ArrayList, HashMap, HashSet	CopyOnWriteArrayList, ConcurrentHashMap

    ⬆ Back to Top

31. What is the difference between process and thread?

    A process and a thread are both units of execution, but they differ significantly in their characteristics and usage.

    Process:

    • Independent executing program with its own memory space
    • Contains at least one thread (main thread)
    • Has its own address space, heap, stack, and system resources
    • Processes are isolated from each other
    • Inter-process communication (IPC) is expensive

    Thread:

    • Lightweight unit of execution within a process
    • Shares memory space with other threads in the same process
    • Has its own stack but shares heap with other threads
    • Threads within a process can communicate directly
    • Context switching between threads is faster

    public class ProcessVsThread {
        public static void main(String[] args) {
            // Creating a new process
            try {
                ProcessBuilder pb = new ProcessBuilder("notepad.exe");
                Process process = pb.start(); // Creates a new process
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            // Creating a new thread
            Thread thread = new Thread(() -> {
                System.out.println("Thread running: " + Thread.currentThread().getName());
            });
            thread.start(); // Creates a new thread within the same process
        }
    }
    

    Process	Thread
    Heavy weight	Light weight
    Own memory space	Shared memory space
    Slower context switching	Faster context switching
    Isolated from other processes	Can communicate with other threads
    More resource intensive	Less resource intensive
    Process crash doesn't affect others	Thread crash can affect entire process

    ⬆ Back to Top

32. What are the different ways to create a thread in Java?

    There are multiple ways to create a thread in Java:

    1. Extending Thread class:

    class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Thread running: " + Thread.currentThread().getName());
        }
    }
    
    // Usage
    MyThread thread = new MyThread();
    thread.start();
    

    2. Implementing Runnable interface:

    class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Runnable running: " + Thread.currentThread().getName());
        }
    }
    
    // Usage
    Thread thread = new Thread(new MyRunnable());
    thread.start();
    

    3. Using Lambda expression (Java 8+):

    Thread thread = new Thread(() -> {
        System.out.println("Lambda thread running");
    });
    thread.start();
    

    4. Implementing Callable interface (returns result):

    import java.util.concurrent.*;
    
    class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            return 42;
        }
    }
    
    // Usage
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future<Integer> future = executor.submit(new MyCallable());
    Integer result = future.get(); // Gets the result
    executor.shutdown();
    

    5. Using ExecutorService:

    ExecutorService executor = Executors.newFixedThreadPool(5);
    
    executor.execute(() -> {
        System.out.println("Task executed by: " + Thread.currentThread().getName());
    });
    
    executor.submit(() -> {
        return "Task completed";
    });
    
    executor.shutdown();
    

    Method	Returns Value	Can Extend Other Class	Exception Handling
    Thread class	No	No	Unchecked only
    Runnable	No	Yes	Unchecked only
    Callable	Yes	Yes	Checked and Unchecked

    ⬆ Back to Top

33. What is synchronization in Java?

    Synchronization is a mechanism that ensures only one thread can access a shared resource at a time. It prevents race conditions and ensures thread safety.

    Types of Synchronization:

    1. Synchronized Method:

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

    2. Synchronized Block:

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

    3. Static Synchronization:

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

    Example demonstrating the need for synchronization:

    class BankAccount {
        private int balance = 1000;
        
        // Without synchronization - race condition possible
        public void withdraw(int amount) {
            if (balance >= amount) {
                System.out.println(Thread.currentThread().getName() + " is withdrawing");
                balance -= amount;
                System.out.println("Balance after withdrawal: " + balance);
            }
        }
        
        // With synchronization - thread safe
        public synchronized void safeWithdraw(int amount) {
            if (balance >= amount) {
                System.out.println(Thread.currentThread().getName() + " is withdrawing");
                balance -= amount;
                System.out.println("Balance after withdrawal: " + balance);
            }
        }
    }
    

    Key Points:

    • Every object in Java has an intrinsic lock (monitor)
    • Only one thread can hold the lock at a time
    • Synchronization can cause performance overhead
    • Prefer synchronized blocks over synchronized methods for fine-grained control

    ⬆ Back to Top

34. What is deadlock and how to avoid it?

    A deadlock is a situation where two or more threads are blocked forever, each waiting for the other to release a lock.

    Deadlock Example:

    public class DeadlockExample {
        private static final Object lock1 = new Object();
        private static final Object lock2 = new Object();
        
        public static void main(String[] args) {
            Thread thread1 = new Thread(() -> {
                synchronized (lock1) {
                    System.out.println("Thread 1: Holding lock1");
                    try { Thread.sleep(100); } catch (InterruptedException e) {}
                    
                    synchronized (lock2) {
                        System.out.println("Thread 1: Holding lock1 and lock2");
                    }
                }
            });
            
            Thread thread2 = new Thread(() -> {
                synchronized (lock2) {
                    System.out.println("Thread 2: Holding lock2");
                    try { Thread.sleep(100); } catch (InterruptedException e) {}
                    
                    synchronized (lock1) {
                        System.out.println("Thread 2: Holding lock2 and lock1");
                    }
                }
            });
            
            thread1.start();
            thread2.start();
        }
    }
    

    How to Avoid Deadlock:

    1. Lock Ordering - Always acquire locks in the same order:

    // Fixed version - both threads acquire locks in same order
    Thread thread1 = new Thread(() -> {
        synchronized (lock1) {
            synchronized (lock2) {
                // work
            }
        }
    });
    
    Thread thread2 = new Thread(() -> {
        synchronized (lock1) {  // Same order as thread1
            synchronized (lock2) {
                // work
            }
        }
    });
    

    2. Use tryLock with timeout:

    import java.util.concurrent.locks.*;
    
    ReentrantLock lock1 = new ReentrantLock();
    ReentrantLock lock2 = new ReentrantLock();
    
    public void safeMethod() {
        boolean gotLock1 = false;
        boolean gotLock2 = false;
        try {
            gotLock1 = lock1.tryLock(1, TimeUnit.SECONDS);
            gotLock2 = lock2.tryLock(1, TimeUnit.SECONDS);
            if (gotLock1 && gotLock2) {
                // Do work
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (gotLock1) lock1.unlock();
            if (gotLock2) lock2.unlock();
        }
    }
    

    3. Avoid nested locks 4. Use lock timeout 5. Avoid holding locks for long periods

    ⬆ Back to Top

35. What is the volatile keyword in Java?

    The volatile keyword in Java is used to indicate that a variable's value may be modified by different threads. It ensures visibility of changes across threads and prevents caching of the variable.

    Key Features:

    1. Visibility: Changes made by one thread are immediately visible to other threads
    2. Atomicity: Read and write operations on volatile variables are atomic (for primitives)
    3. No Caching: The variable is always read from main memory, not from CPU cache

    public class VolatileExample {
        private volatile boolean running = true;
        
        public void stop() {
            running = false;
        }
        
        public void run() {
            while (running) {
                // Do work
            }
            System.out.println("Stopped");
        }
        
        public static void main(String[] args) throws InterruptedException {
            VolatileExample example = new VolatileExample();
            
            Thread worker = new Thread(() -> example.run());
            worker.start();
            
            Thread.sleep(1000);
            example.stop(); // This change will be visible to the worker thread
        }
    }
    

    Without volatile:

    // Without volatile, the worker thread might never see the change
    // because it may read from its local cache
    private boolean running = true; // Thread may cache this value
    

    Volatile vs Synchronized:

    volatile	synchronized
    Only ensures visibility	Ensures visibility and atomicity
    No blocking	Causes blocking
    Cannot be used for compound operations	Can protect compound operations
    Less overhead	More overhead

    Note: Volatile is not suitable for compound operations like count++. Use AtomicInteger or synchronized for such cases.

    ⬆ Back to Top

36. What is the transient keyword in Java?

    The transient keyword in Java is used to indicate that a field should not be serialized when the object is converted to a byte stream.

    Use Cases:

    • Sensitive data like passwords
    • Calculated/derived fields
    • Non-serializable fields
    • Thread-local data

    import java.io.*;
    
    class User implements Serializable {
        private static final long serialVersionUID = 1L;
        
        private String username;
        private transient String password;  // Will not be serialized
        private transient int loginCount;   // Will not be serialized
        
        public User(String username, String password) {
            this.username = username;
            this.password = password;
            this.loginCount = 0;
        }
        
        @Override
        public String toString() {
            return "User{username='" + username + "', password='" + password + 
                   "', loginCount=" + loginCount + "}";
        }
    }
    
    public class TransientDemo {
        public static void main(String[] args) {
            User user = new User("john", "secret123");
            user.loginCount = 5;
            System.out.println("Before serialization: " + user);
            
            // Serialize
            try (ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("user.ser"))) {
                oos.writeObject(user);
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            // Deserialize
            try (ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("user.ser"))) {
                User deserializedUser = (User) ois.readObject();
                System.out.println("After deserialization: " + deserializedUser);
                // Output: User{username='john', password='null', loginCount=0}
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    Key Points:

    • Transient fields get default values after deserialization (null for objects, 0 for numbers, false for boolean)
    • Static fields are not serialized regardless of transient keyword
    • Can be combined with custom readObject/writeObject for complex scenarios

    ⬆ Back to Top

37. What is serialization and deserialization?

    Serialization is the process of converting an object's state into a byte stream. Deserialization is the reverse process - converting a byte stream back into an object.

    Why Serialization?

    • Persist object state to file/database
    • Send objects over network
    • Deep copy objects
    • Cache objects

    import java.io.*;
    
    class Employee implements Serializable {
        private static final long serialVersionUID = 1L;
        
        private String name;
        private int id;
        private transient double salary; // Not serialized
        
        public Employee(String name, int id, double salary) {
            this.name = name;
            this.id = id;
            this.salary = salary;
        }
        
        @Override
        public String toString() {
            return "Employee{name='" + name + "', id=" + id + ", salary=" + salary + "}";
        }
    }
    
    public class SerializationDemo {
        public static void main(String[] args) {
            Employee emp = new Employee("John", 101, 50000);
            
            // Serialization
            try (ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("employee.ser"))) {
                oos.writeObject(emp);
                System.out.println("Object serialized successfully");
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            // Deserialization
            try (ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("employee.ser"))) {
                Employee deserializedEmp = (Employee) ois.readObject();
                System.out.println("Deserialized: " + deserializedEmp);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    Custom Serialization:

    class CustomSerializable implements Serializable {
        private String data;
        private transient String sensitiveData;
        
        private void writeObject(ObjectOutputStream oos) throws IOException {
            oos.defaultWriteObject();
            // Encrypt and write sensitive data
            oos.writeObject(encrypt(sensitiveData));
        }
        
        private void readObject(ObjectInputStream ois) 
                throws IOException, ClassNotFoundException {
            ois.defaultReadObject();
            // Decrypt sensitive data
            sensitiveData = decrypt((String) ois.readObject());
        }
        
        private String encrypt(String data) { return data; } // Placeholder
        private String decrypt(String data) { return data; } // Placeholder
    }
    

    Important: Always declare serialVersionUID to maintain compatibility during deserialization.

    ⬆ Back to Top

38. What are functional interfaces in Java?

    A functional interface is an interface that contains exactly one abstract method. They are the foundation for lambda expressions in Java 8.

    Key Characteristics:

    • Has exactly one abstract method
    • Can have multiple default and static methods
    • Can be annotated with @FunctionalInterface
    • Used as target types for lambda expressions

    @FunctionalInterface
    interface Calculator {
        int calculate(int a, int b);
        
        // Default method - allowed
        default void print(String msg) {
            System.out.println(msg);
        }
        
        // Static method - allowed
        static void info() {
            System.out.println("Calculator interface");
        }
    }
    
    public class FunctionalInterfaceDemo {
        public static void main(String[] args) {
            // Using lambda expression
            Calculator add = (a, b) -> a + b;
            Calculator multiply = (a, b) -> a * b;
            
            System.out.println("Sum: " + add.calculate(5, 3));      // 8
            System.out.println("Product: " + multiply.calculate(5, 3)); // 15
        }
    }
    

    Built-in Functional Interfaces (java.util.function):

    import java.util.function.*;
    
    public class BuiltInFunctionalInterfaces {
        public static void main(String[] args) {
            // Predicate - takes input, returns boolean
            Predicate<Integer> isEven = n -> n % 2 == 0;
            System.out.println(isEven.test(4)); // true
            
            // Function - takes input, returns output
            Function<String, Integer> length = s -> s.length();
            System.out.println(length.apply("Hello")); // 5
            
            // Consumer - takes input, returns nothing
            Consumer<String> printer = s -> System.out.println(s);
            printer.accept("Hello"); // prints Hello
            
            // Supplier - takes nothing, returns output
            Supplier<Double> random = () -> Math.random();
            System.out.println(random.get()); // random number
            
            // BiFunction - takes two inputs, returns output
            BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
            System.out.println(add.apply(5, 3)); // 8
            
            // UnaryOperator - takes input, returns same type
            UnaryOperator<Integer> square = n -> n * n;
            System.out.println(square.apply(5)); // 25
            
            // BinaryOperator - takes two inputs of same type, returns same type
            BinaryOperator<Integer> max = (a, b) -> a > b ? a : b;
            System.out.println(max.apply(5, 3)); // 5
        }
    }
    

    ⬆ Back to Top

39. What are lambda expressions in Java?

    Lambda expressions are anonymous functions that provide a concise way to implement functional interfaces. Introduced in Java 8, they enable functional programming in Java.

    Syntax:

    (parameters) -> expression
    (parameters) -> { statements; }
    

    Examples:

    import java.util.*;
    import java.util.function.*;
    
    public class LambdaExamples {
        public static void main(String[] args) {
            // No parameters
            Runnable runnable = () -> System.out.println("Hello Lambda!");
            runnable.run();
            
            // One parameter (parentheses optional)
            Consumer<String> consumer = s -> System.out.println(s);
            consumer.accept("Hello");
            
            // Multiple parameters
            BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
            System.out.println(add.apply(5, 3));
            
            // With type declarations
            BiFunction<Integer, Integer, Integer> multiply = 
                (Integer a, Integer b) -> a * b;
            
            // Multiple statements (braces required)
            BiFunction<Integer, Integer, Integer> calculate = (a, b) -> {
                int sum = a + b;
                int product = a * b;
                return sum + product;
            };
            
            // With Collections
            List<String> names = Arrays.asList("John", "Jane", "Bob", "Alice");
            
            // forEach with lambda
            names.forEach(name -> System.out.println(name));
            
            // Method reference (shorthand for lambda)
            names.forEach(System.out::println);
            
            // Sorting with lambda
            names.sort((s1, s2) -> s1.compareTo(s2));
            
            // Using Comparator method reference
            names.sort(String::compareTo);
            
            // Filtering with streams
            List<String> filtered = names.stream()
                .filter(name -> name.startsWith("J"))
                .collect(Collectors.toList());
            
            // Mapping with streams
            List<Integer> lengths = names.stream()
                .map(name -> name.length())
                .collect(Collectors.toList());
        }
    }
    

    Method References:

    // Static method reference
    Function<String, Integer> parseInt = Integer::parseInt;
    
    // Instance method reference
    String str = "Hello";
    Supplier<Integer> length = str::length;
    
    // Constructor reference
    Supplier<ArrayList<String>> listSupplier = ArrayList::new;
    

    Benefits:

    • Concise and readable code
    • Enables functional programming
    • Better support for parallel processing
    • Reduced boilerplate code

    ⬆ Back to Top

40. What is Optional class in Java 8?

    The Optional class is a container object that may or may not contain a non-null value. It helps avoid NullPointerException and makes null handling more explicit.

    Creating Optional:

    import java.util.Optional;
    
    public class OptionalDemo {
        public static void main(String[] args) {
            // Creating Optional
            Optional<String> empty = Optional.empty();
            Optional<String> name = Optional.of("John");
            Optional<String> nullable = Optional.ofNullable(null);
            
            // Checking if value present
            System.out.println(name.isPresent());     // true
            System.out.println(empty.isPresent());    // false
            System.out.println(empty.isEmpty());      // true (Java 11+)
            
            // Getting value
            String value = name.get();  // Returns "John"
            // String error = empty.get(); // Throws NoSuchElementException
            
            // Safe access with orElse
            String defaultName = empty.orElse("Unknown");  // "Unknown"
            
            // orElseGet - lazy evaluation
            String lazyDefault = empty.orElseGet(() -> computeDefault());
            
            // orElseThrow
            String required = name.orElseThrow(() -> 
                new IllegalArgumentException("Name is required"));
            
            // ifPresent - execute if value exists
            name.ifPresent(n -> System.out.println("Name: " + n));
            
            // ifPresentOrElse (Java 9+)
            name.ifPresentOrElse(
                n -> System.out.println("Found: " + n),
                () -> System.out.println("Not found")
            );
        }
        
        static String computeDefault() {
            return "Computed Default";
        }
    }
    

    Optional with Streams:

    public class OptionalStreams {
        public static void main(String[] args) {
            Optional<String> name = Optional.of("  John  ");
            
            // map - transform value
            Optional<Integer> length = name.map(String::length);
            
            // Chaining operations
            String result = name
                .map(String::trim)
                .map(String::toUpperCase)
                .orElse("UNKNOWN");
            System.out.println(result);  // "JOHN"
            
            // filter - conditional
            Optional<String> filtered = name
                .filter(n -> n.trim().length() > 3);
            
            // flatMap - for nested Optionals
            Optional<Optional<String>> nested = Optional.of(Optional.of("Hello"));
            Optional<String> flat = nested.flatMap(o -> o);
        }
    }
    

    Best Practices:

    class UserService {
        // Return Optional for methods that may not find a result
        public Optional<User> findById(int id) {
            User user = database.find(id);
            return Optional.ofNullable(user);
        }
        
        // Don't use Optional for fields or parameters
        // Bad: private Optional<String> name;
        // Good: private String name; // can be null
        
        // Don't use Optional.get() without checking
        // Bad: optional.get()
        // Good: optional.orElse(default) or optional.ifPresent(...)
    }
    

    ⬆ Back to Top

41. What is the difference between Collection and Collections?

    Collection and Collections are two different concepts in Java that are often confused.

    Collection (Interface):

    • It is a root interface in the Java Collections Framework
    • Located in java.util package
    • Represents a group of objects known as elements
    • Extended by List, Set, and Queue interfaces

    Collections (Utility Class):

    • It is a utility class that provides static methods for collection operations
    • Located in java.util package
    • Contains methods for sorting, searching, shuffling, reversing, etc.
    • Cannot be instantiated (all methods are static)

    import java.util.*;
    
    public class CollectionVsCollections {
        public static void main(String[] args) {
            // Collection - interface used to create a collection
            Collection<String> collection = new ArrayList<>();
            collection.add("Apple");
            collection.add("Banana");
            collection.add("Cherry");
            
            // Collections - utility class with static methods
            List<String> list = new ArrayList<>(collection);
            
            // Sorting using Collections utility
            Collections.sort(list);
            System.out.println("Sorted: " + list);
            
            // Reverse the list
            Collections.reverse(list);
            System.out.println("Reversed: " + list);
            
            // Shuffle the list
            Collections.shuffle(list);
            System.out.println("Shuffled: " + list);
            
            // Find min and max
            System.out.println("Min: " + Collections.min(list));
            System.out.println("Max: " + Collections.max(list));
            
            // Create unmodifiable collection
            List<String> unmodifiable = Collections.unmodifiableList(list);
            
            // Create synchronized collection
            List<String> syncList = Collections.synchronizedList(new ArrayList<>());
        }
    }
    

    Collection	Collections
    Interface	Utility class
    Used to represent a group of objects	Provides static methods for operations
    Can be implemented	Cannot be instantiated
    Root of Collection hierarchy	Helper class for Collection operations

    ⬆ Back to Top

42. What is the difference between Set and List?

    Both Set and List are interfaces in the Java Collections Framework, but they have different characteristics:

    List	Set
    Allows duplicate elements	Does not allow duplicate elements
    Maintains insertion order	May or may not maintain order (depends on implementation)
    Elements can be accessed by index	No index-based access
    Allows multiple null values	Allows at most one null value (HashSet, LinkedHashSet)
    Implementations: ArrayList, LinkedList, Vector	Implementations: HashSet, LinkedHashSet, TreeSet

    import java.util.*;
    
    public class ListVsSet {
        public static void main(String[] args) {
            // List - allows duplicates, maintains order
            List<String> list = new ArrayList<>();
            list.add("Apple");
            list.add("Banana");
            list.add("Apple");  // Duplicate allowed
            list.add(null);
            list.add(null);     // Multiple nulls allowed
            System.out.println("List: " + list);  // [Apple, Banana, Apple, null, null]
            System.out.println("Element at index 1: " + list.get(1));  // Index access
            
            // Set - no duplicates
            Set<String> hashSet = new HashSet<>();
            hashSet.add("Apple");
            hashSet.add("Banana");
            hashSet.add("Apple");  // Duplicate ignored
            hashSet.add(null);     // Only one null allowed
            System.out.println("HashSet: " + hashSet);  // Order not guaranteed
            
            // LinkedHashSet - maintains insertion order
            Set<String> linkedHashSet = new LinkedHashSet<>();
            linkedHashSet.add("Cherry");
            linkedHashSet.add("Apple");
            linkedHashSet.add("Banana");
            System.out.println("LinkedHashSet: " + linkedHashSet);  // [Cherry, Apple, Banana]
            
            // TreeSet - sorted order, no nulls
            Set<String> treeSet = new TreeSet<>();
            treeSet.add("Cherry");
            treeSet.add("Apple");
            treeSet.add("Banana");
            System.out.println("TreeSet: " + treeSet);  // [Apple, Banana, Cherry]
        }
    }
    

    When to use:

    • Use List when you need to maintain insertion order and allow duplicates
    • Use Set when you need to store unique elements only

    ⬆ Back to Top

43. What is the difference between HashSet and TreeSet?

    Both HashSet and TreeSet implement the Set interface but have different internal implementations and characteristics:

    HashSet	TreeSet
    Uses HashMap internally	Uses TreeMap (Red-Black Tree) internally
    Does not maintain any order	Maintains elements in sorted (natural) order
    Allows one null element	Does not allow null elements
    O(1) for add, remove, contains	O(log n) for add, remove, contains
    Uses hashCode() and equals()	Uses compareTo() or Comparator
    Better performance for basic operations	Better when sorted order is needed

    import java.util.*;
    
    public class HashSetVsTreeSet {
        public static void main(String[] args) {
            // HashSet - no ordering, allows null
            Set<Integer> hashSet = new HashSet<>();
            hashSet.add(30);
            hashSet.add(10);
            hashSet.add(20);
            hashSet.add(null);  // Allowed
            hashSet.add(10);    // Duplicate ignored
            System.out.println("HashSet: " + hashSet);  // Order not guaranteed
            
            // TreeSet - sorted order, no null
            Set<Integer> treeSet = new TreeSet<>();
            treeSet.add(30);
            treeSet.add(10);
            treeSet.add(20);
            // treeSet.add(null);  // Throws NullPointerException
            System.out.println("TreeSet: " + treeSet);  // [10, 20, 30] - sorted
            
            // TreeSet with custom Comparator (descending order)
            Set<Integer> descendingSet = new TreeSet<>(Collections.reverseOrder());
            descendingSet.add(30);
            descendingSet.add(10);
            descendingSet.add(20);
            System.out.println("Descending TreeSet: " + descendingSet);  // [30, 20, 10]
            
            // TreeSet with custom objects
            Set<Person> personSet = new TreeSet<>(Comparator.comparing(Person::getName));
            personSet.add(new Person("John", 25));
            personSet.add(new Person("Alice", 30));
            personSet.add(new Person("Bob", 20));
            System.out.println("Person TreeSet: " + personSet);
        }
    }
    
    class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String getName() { return name; }
        public int getAge() { return age; }
        
        @Override
        public String toString() {
            return name + "(" + age + ")";
        }
    }
    

    ⬆ Back to Top

44. What is the diamond problem in Java?

    The diamond problem is an ambiguity that arises in multiple inheritance when a class inherits from two classes that both inherit from a common superclass. It's called "diamond" because of the shape of the inheritance diagram.

    The Problem:

           A
          / \
         B   C
          \ /
           D
    

    If class D inherits from both B and C, and both B and C override a method from A, which version should D use?

    Java's Solution: Java does not allow multiple inheritance with classes to avoid the diamond problem. However, with Java 8+ interfaces having default methods, a similar situation can occur:

    interface A {
        default void display() {
            System.out.println("Display from A");
        }
    }
    
    interface B extends A {
        @Override
        default void display() {
            System.out.println("Display from B");
        }
    }
    
    interface C extends A {
        @Override
        default void display() {
            System.out.println("Display from C");
        }
    }
    
    // Diamond problem with interfaces
    class D implements B, C {
        // Must override to resolve ambiguity
        @Override
        public void display() {
            // Can choose which interface method to call
            B.super.display();  // Calls B's display
            // or
            // C.super.display();  // Calls C's display
            // or provide own implementation
            System.out.println("Display from D");
        }
    }
    
    public class DiamondProblem {
        public static void main(String[] args) {
            D d = new D();
            d.display();
        }
    }
    

    Resolution Rules in Java:

    1. Class wins over interface: If a class inherits a method from both a superclass and an interface, the class method takes precedence
    2. Subtype wins: More specific interface's default method is chosen over less specific one
    3. Explicit resolution: If still ambiguous, the class must explicitly override and specify which method to use

    class Parent {
        void show() {
            System.out.println("Parent show");
        }
    }
    
    interface MyInterface {
        default void show() {
            System.out.println("Interface show");
        }
    }
    
    // Class method wins over interface default method
    class Child extends Parent implements MyInterface {
        // No override needed - Parent's show() is used automatically
    }
    

    ⬆ Back to Top

45. What is dependency injection?

    Dependency Injection (DI) is a design pattern used to implement Inversion of Control (IoC). It allows the creation of dependent objects outside of a class and provides those objects to a class in different ways.

    Benefits of Dependency Injection:

    1. Loose coupling between classes
    2. Easier unit testing (mock dependencies)
    3. Better code reusability
    4. Easier maintenance and flexibility

    Types of Dependency Injection:

    1. Constructor Injection:

    // Dependency
    interface MessageService {
        void sendMessage(String message);
    }
    
    class EmailService implements MessageService {
        @Override
        public void sendMessage(String message) {
            System.out.println("Email sent: " + message);
        }
    }
    
    class SMSService implements MessageService {
        @Override
        public void sendMessage(String message) {
            System.out.println("SMS sent: " + message);
        }
    }
    
    // Constructor Injection
    class NotificationService {
        private final MessageService messageService;
        
        // Dependency injected through constructor
        public NotificationService(MessageService messageService) {
            this.messageService = messageService;
        }
        
        public void notify(String message) {
            messageService.sendMessage(message);
        }
    }
    

    2. Setter Injection:

    class NotificationService {
        private MessageService messageService;
        
        // Dependency injected through setter
        public void setMessageService(MessageService messageService) {
            this.messageService = messageService;
        }
        
        public void notify(String message) {
            messageService.sendMessage(message);
        }
    }
    

    3. Interface Injection:

    interface MessageServiceInjector {
        void injectMessageService(MessageService service);
    }
    
    class NotificationService implements MessageServiceInjector {
        private MessageService messageService;
        
        @Override
        public void injectMessageService(MessageService service) {
            this.messageService = service;
        }
        
        public void notify(String message) {
            messageService.sendMessage(message);
        }
    }
    

    Usage Example:

    public class DIExample {
        public static void main(String[] args) {
            // Create dependencies
            MessageService emailService = new EmailService();
            MessageService smsService = new SMSService();
            
            // Inject dependencies
            NotificationService notifier1 = new NotificationService(emailService);
            notifier1.notify("Hello via Email!");
            
            NotificationService notifier2 = new NotificationService(smsService);
            notifier2.notify("Hello via SMS!");
        }
    }
    

    Note: Frameworks like Spring provide automatic dependency injection using annotations like @Autowired, @Inject.

    ⬆ Back to Top

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

    When copying objects in Java, there are two types of copies: shallow copy and deep copy.

    Shallow Copy:

    • Creates a new object but copies references to nested objects
    • Changes to nested objects affect both copies
    • Default behavior of clone() method

    Deep Copy:

    • Creates a new object and recursively copies all nested objects
    • Changes to nested objects don't affect the original
    • Requires manual implementation

    import java.util.ArrayList;
    import java.util.List;
    
    class Address implements Cloneable {
        String city;
        
        public Address(String city) {
            this.city = city;
        }
        
        @Override
        protected Address clone() throws CloneNotSupportedException {
            return (Address) super.clone();
        }
        
        @Override
        public String toString() {
            return city;
        }
    }
    
    class Person implements Cloneable {
        String name;
        Address address;
        List<String> hobbies;
        
        public Person(String name, Address address, List<String> hobbies) {
            this.name = name;
            this.address = address;
            this.hobbies = hobbies;
        }
        
        // Shallow Copy
        public Person shallowCopy() throws CloneNotSupportedException {
            return (Person) super.clone();
        }
        
        // Deep Copy
        public Person deepCopy() throws CloneNotSupportedException {
            Person cloned = (Person) super.clone();
            cloned.address = this.address.clone();  // Clone nested object
            cloned.hobbies = new ArrayList<>(this.hobbies);  // Create new list
            return cloned;
        }
        
        @Override
        public String toString() {
            return "Person{name='" + name + "', address=" + address + ", hobbies=" + hobbies + "}";
        }
    }
    
    public class CopyExample {
        public static void main(String[] args) throws CloneNotSupportedException {
            List<String> hobbies = new ArrayList<>();
            hobbies.add("Reading");
            
            Person original = new Person("John", new Address("New York"), hobbies);
            
            // Shallow Copy
            Person shallowCopy = original.shallowCopy();
            
            // Deep Copy
            Person deepCopy = original.deepCopy();
            
            // Modify nested objects
            original.address.city = "Los Angeles";
            original.hobbies.add("Gaming");
            
            System.out.println("Original: " + original);
            System.out.println("Shallow Copy: " + shallowCopy);  // Address changed!
            System.out.println("Deep Copy: " + deepCopy);        // Address unchanged
        }
    }
    

    Shallow Copy	Deep Copy
    Copies object references	Copies actual objects
    Nested objects are shared	Nested objects are independent
    Faster and less memory	Slower and more memory
    Changes affect both copies	Changes are isolated
    Default clone() behavior	Requires custom implementation

    ⬆ Back to Top

47. What are design patterns in Java?

    Design patterns are reusable solutions to common problems in software design. They represent best practices and provide templates for solving design challenges.

    Categories of Design Patterns:

    1. Creational Patterns - Deal with object creation mechanisms

       • Singleton
       • Factory Method
       • Abstract Factory
       • Builder
       • Prototype

    2. Structural Patterns - Deal with object composition

       • Adapter
       • Bridge
       • Composite
       • Decorator
       • Facade
       • Flyweight
       • Proxy

    3. Behavioral Patterns - Deal with object interaction

       • Chain of Responsibility
       • Command
       • Iterator
       • Mediator
       • Memento
       • Observer
       • State
       • Strategy
       • Template Method
       • Visitor

    Common Design Patterns Examples:

    // 1. SINGLETON - Only one instance
    public class Singleton {
        private static Singleton instance;
        private Singleton() {}
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    
    // 2. FACTORY - Creates objects without exposing creation logic
    interface Animal {
        void speak();
    }
    class Dog implements Animal {
        public void speak() { System.out.println("Woof!"); }
    }
    class Cat implements Animal {
        public void speak() { System.out.println("Meow!"); }
    }
    class AnimalFactory {
        public static Animal createAnimal(String type) {
            return switch (type.toLowerCase()) {
                case "dog" -> new Dog();
                case "cat" -> new Cat();
                default -> throw new IllegalArgumentException("Unknown animal");
            };
        }
    }
    
    // 3. OBSERVER - One-to-many dependency
    interface Observer {
        void update(String message);
    }
    class NewsSubscriber implements Observer {
        private String name;
        public NewsSubscriber(String name) { this.name = name; }
        public void update(String message) {
            System.out.println(name + " received: " + message);
        }
    }
    
    // 4. STRATEGY - Family of interchangeable algorithms
    interface PaymentStrategy {
        void pay(int amount);
    }
    class CreditCardPayment implements PaymentStrategy {
        public void pay(int amount) {
            System.out.println("Paid $" + amount + " with Credit Card");
        }
    }
    class PayPalPayment implements PaymentStrategy {
        public void pay(int amount) {
            System.out.println("Paid $" + amount + " with PayPal");
        }
    }
    
    // 5. DECORATOR - Add behavior dynamically
    interface Coffee {
        double getCost();
        String getDescription();
    }
    class SimpleCoffee implements Coffee {
        public double getCost() { return 2.0; }
        public String getDescription() { return "Simple Coffee"; }
    }
    class MilkDecorator implements Coffee {
        private Coffee coffee;
        public MilkDecorator(Coffee coffee) { this.coffee = coffee; }
        public double getCost() { return coffee.getCost() + 0.5; }
        public String getDescription() { return coffee.getDescription() + ", Milk"; }
    }
    

    ⬆ Back to Top

48. What is the factory design pattern?

    The Factory Design Pattern is a creational pattern that provides an interface for creating objects without specifying their exact classes. It delegates the instantiation logic to subclasses or factory methods.

    Types of Factory Patterns:

    1. Simple Factory (Static Factory Method):

    interface Shape {
        void draw();
    }
    
    class Circle implements Shape {
        @Override
        public void draw() {
            System.out.println("Drawing Circle");
        }
    }
    
    class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Drawing Rectangle");
        }
    }
    
    class Triangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Drawing Triangle");
        }
    }
    
    // Simple Factory
    class ShapeFactory {
        public static Shape createShape(String shapeType) {
            if (shapeType == null) {
                return null;
            }
            return switch (shapeType.toUpperCase()) {
                case "CIRCLE" -> new Circle();
                case "RECTANGLE" -> new Rectangle();
                case "TRIANGLE" -> new Triangle();
                default -> throw new IllegalArgumentException("Unknown shape: " + shapeType);
            };
        }
    }
    
    public class SimpleFactoryDemo {
        public static void main(String[] args) {
            Shape circle = ShapeFactory.createShape("CIRCLE");
            circle.draw();
            
            Shape rectangle = ShapeFactory.createShape("RECTANGLE");
            rectangle.draw();
        }
    }
    

    2. Factory Method Pattern:

    // Product interface
    interface Vehicle {
        void drive();
    }
    
    class Car implements Vehicle {
        @Override
        public void drive() {
            System.out.println("Driving a car");
        }
    }
    
    class Motorcycle implements Vehicle {
        @Override
        public void drive() {
            System.out.println("Riding a motorcycle");
        }
    }
    
    // Creator abstract class
    abstract class VehicleFactory {
        // Factory method
        public abstract Vehicle createVehicle();
        
        public void deliverVehicle() {
            Vehicle vehicle = createVehicle();
            System.out.println("Delivering vehicle...");
            vehicle.drive();
        }
    }
    
    class CarFactory extends VehicleFactory {
        @Override
        public Vehicle createVehicle() {
            return new Car();
        }
    }
    
    class MotorcycleFactory extends VehicleFactory {
        @Override
        public Vehicle createVehicle() {
            return new Motorcycle();
        }
    }
    
    public class FactoryMethodDemo {
        public static void main(String[] args) {
            VehicleFactory carFactory = new CarFactory();
            carFactory.deliverVehicle();
            
            VehicleFactory motorcycleFactory = new MotorcycleFactory();
            motorcycleFactory.deliverVehicle();
        }
    }
    

    Benefits:

    • Loose coupling between creator and products
    • Single Responsibility Principle - creation code in one place
    • Open/Closed Principle - easy to add new product types
    • Easier unit testing with mock objects

    ⬆ Back to Top

49. What is the builder design pattern?

    The Builder Design Pattern is a creational pattern that separates the construction of a complex object from its representation. It allows step-by-step construction of objects and produces different representations using the same construction process.

    When to use:

    • When object has many optional parameters
    • When object creation involves many steps
    • When you want immutable objects with many fields

    // Product class with many fields
    class Computer {
        // Required parameters
        private final String processor;
        private final int ram;
        
        // Optional parameters
        private final int storage;
        private final boolean hasGraphicsCard;
        private final boolean hasBluetooth;
        private final boolean hasWifi;
        private final String operatingSystem;
        
        private Computer(ComputerBuilder builder) {
            this.processor = builder.processor;
            this.ram = builder.ram;
            this.storage = builder.storage;
            this.hasGraphicsCard = builder.hasGraphicsCard;
            this.hasBluetooth = builder.hasBluetooth;
            this.hasWifi = builder.hasWifi;
            this.operatingSystem = builder.operatingSystem;
        }
        
        // Getters
        public String getProcessor() { return processor; }
        public int getRam() { return ram; }
        public int getStorage() { return storage; }
        public boolean hasGraphicsCard() { return hasGraphicsCard; }
        public boolean hasBluetooth() { return hasBluetooth; }
        public boolean hasWifi() { return hasWifi; }
        public String getOperatingSystem() { return operatingSystem; }
        
        @Override
        public String toString() {
            return "Computer{" +
                "processor='" + processor + '\'' +
                ", ram=" + ram + "GB" +
                ", storage=" + storage + "GB" +
                ", graphicsCard=" + hasGraphicsCard +
                ", bluetooth=" + hasBluetooth +
                ", wifi=" + hasWifi +
                ", OS='" + operatingSystem + '\'' +
                '}';
        }
        
        // Static Builder class
        public static class ComputerBuilder {
            // Required parameters
            private final String processor;
            private final int ram;
            
            // Optional parameters with default values
            private int storage = 256;
            private boolean hasGraphicsCard = false;
            private boolean hasBluetooth = true;
            private boolean hasWifi = true;
            private String operatingSystem = "Windows";
            
            // Constructor with required parameters
            public ComputerBuilder(String processor, int ram) {
                this.processor = processor;
                this.ram = ram;
            }
            
            // Builder methods for optional parameters
            public ComputerBuilder storage(int storage) {
                this.storage = storage;
                return this;
            }
            
            public ComputerBuilder graphicsCard(boolean hasGraphicsCard) {
                this.hasGraphicsCard = hasGraphicsCard;
                return this;
            }
            
            public ComputerBuilder bluetooth(boolean hasBluetooth) {
                this.hasBluetooth = hasBluetooth;
                return this;
            }
            
            public ComputerBuilder wifi(boolean hasWifi) {
                this.hasWifi = hasWifi;
                return this;
            }
            
            public ComputerBuilder operatingSystem(String operatingSystem) {
                this.operatingSystem = operatingSystem;
                return this;
            }
            
            // Build method to create the final object
            public Computer build() {
                return new Computer(this);
            }
        }
    }
    
    public class BuilderPatternDemo {
        public static void main(String[] args) {
            // Building a gaming computer
            Computer gamingPC = new Computer.ComputerBuilder("Intel i9", 32)
                .storage(1000)
                .graphicsCard(true)
                .bluetooth(true)
                .wifi(true)
                .operatingSystem("Windows 11")
                .build();
            
            System.out.println("Gaming PC: " + gamingPC);
            
            // Building a basic computer with defaults
            Computer basicPC = new Computer.ComputerBuilder("Intel i3", 8)
                .build();
            
            System.out.println("Basic PC: " + basicPC);
            
            // Building a Mac
            Computer mac = new Computer.ComputerBuilder("Apple M2", 16)
                .storage(512)
                .operatingSystem("macOS")
                .build();
            
            System.out.println("Mac: " + mac);
        }
    }
    

    Benefits:

    • Readable code with method chaining (fluent interface)
    • Immutable objects can be created easily
    • Clear separation of construction and representation
    • Avoids telescoping constructor anti-pattern

    ⬆ Back to Top

50. What is the difference between Heap and Stack memory?

    Java memory is divided into two main areas: Heap and Stack. Understanding their differences is crucial for memory management.

    Stack Memory	Heap Memory
    Stores method calls and local variables	Stores objects and instance variables
    LIFO (Last In First Out) structure	No specific order
    Thread-safe (each thread has own stack)	Shared among all threads
    Memory allocation/deallocation is automatic	Managed by Garbage Collector
    Fixed size (can cause StackOverflowError)	Dynamic size (can cause OutOfMemoryError)
    Faster access	Slower access
    Stores primitive values and references	Stores actual objects

    public class MemoryExample {
        // Instance variable - stored in Heap
        private int instanceVar = 10;
        
        // Static variable - stored in Method Area (part of Heap in modern JVMs)
        private static int staticVar = 20;
        
        public void demonstrate() {
            // Local primitive - stored in Stack
            int localPrimitive = 30;
            
            // Local reference - reference in Stack, object in Heap
            String localString = new String("Hello");
            
            // Object created in Heap
            Person person = new Person("John", 25);
            
            // Array - reference in Stack, array object in Heap
            int[] numbers = new int[5];
        }
        
        public static void main(String[] args) {
            // Reference 'obj' in Stack, object in Heap
            MemoryExample obj = new MemoryExample();
            obj.demonstrate();
            
            // Recursive call can cause StackOverflowError
            // recursiveMethod(); // Uncomment to see StackOverflowError
        }
        
        public static void recursiveMethod() {
            recursiveMethod(); // Infinite recursion - StackOverflowError
        }
    }
    
    class Person {
        String name;  // Reference in Heap, String object in Heap
        int age;      // Primitive stored in Heap (as part of object)
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    

    Memory Visualization:

    STACK                          HEAP
    ┌─────────────────┐            ┌─────────────────────────────────┐
    │ main() frame    │            │                                 │
    │  obj (reference)│──────────► │  MemoryExample object           │
    │                 │            │    instanceVar = 10             │
    ├─────────────────┤            │                                 │
    │ demonstrate()   │            ├─────────────────────────────────┤
    │  localPrimitive │            │                                 │
    │  = 30           │            │  String object "Hello"          │
    │  localString ───│──────────► │                                 │
    │  person ────────│──────────► │  Person object                  │
    │  numbers ───────│──────────► │    name (ref) ──► "John"        │
    └─────────────────┘            │    age = 25                     │
                                   │                                 │
                                   │  int[5] array                   │
                                   └─────────────────────────────────┘
    

    ⬆ Back to Top

51. What is garbage collection in Java?

    Garbage Collection (GC) is an automatic memory management feature in Java that identifies and removes objects that are no longer in use, freeing up heap memory for new objects.

    How Garbage Collection Works:

    1. Mark Phase: GC identifies which objects are still reachable (in use)
    2. Sweep Phase: GC removes unreachable objects
    3. Compact Phase (optional): GC compacts remaining objects to reduce fragmentation

    When does an object become eligible for GC?

    • When no references point to it
    • When reference is set to null
    • When reference is reassigned
    • When object goes out of scope

    public class GarbageCollectionDemo {
        
        public static void main(String[] args) {
            // Object created - not eligible for GC
            Object obj1 = new Object();
            
            // Reference set to null - obj1's object eligible for GC
            obj1 = null;
            
            // Object reassignment - first object eligible for GC
            Object obj2 = new Object();
            obj2 = new Object();  // First object now eligible for GC
            
            // Objects in method scope
            createObjects();
            // After method returns, local objects are eligible for GC
            
            // Request garbage collection (not guaranteed to run immediately)
            System.gc();
            // or
            Runtime.getRuntime().gc();
        }
        
        static void createObjects() {
            Object localObj = new Object();
            // localObj goes out of scope when method returns
        }
    }
    
    // Using finalize() - deprecated but shows GC callback
    class MyObject {
        private String name;
        
        public MyObject(String name) {
            this.name = name;
            System.out.println(name + " created");
        }
        
        @Override
        protected void finalize() throws Throwable {
            System.out.println(name + " is being garbage collected");
            super.finalize();
        }
    }
    
    // Demonstrating object eligibility
    class GCEligibility {
        public static void main(String[] args) throws InterruptedException {
            // Island of isolation - objects reference each other but unreachable
            MyObject a = new MyObject("A");
            MyObject b = new MyObject("B");
            
            // Create circular reference
            // a.partner = b;
            // b.partner = a;
            
            // Both become eligible for GC (island of isolation)
            a = null;
            b = null;
            
            // Request GC
            System.gc();
            Thread.sleep(1000);  // Give GC time to run
        }
    }
    

    JVM Heap Generations:

    ┌────────────────────────────────────────────────────────────┐
    │                          HEAP                              │
    ├─────────────────────────────┬──────────────────────────────┤
    │     Young Generation        │      Old Generation          │
    │  ┌───────┬───────┬───────┐  │      (Tenured)               │
    │  │ Eden  │  S0   │  S1   │  │                              │
    │  │       │(From) │ (To)  │  │   Long-lived objects         │
    │  │ New   │       │       │  │                              │
    │  │objects│Survivor Spaces│  │                              │
    │  └───────┴───────┴───────┘  │                              │
    └─────────────────────────────┴──────────────────────────────┘
    

    GC Process:

    1. New objects are allocated in Eden space
    2. When Eden fills up, Minor GC occurs
    3. Surviving objects move to Survivor space
    4. Objects that survive multiple Minor GCs move to Old Generation
    5. When Old Generation fills up, Major GC (Full GC) occurs

    JVM GC Options:

    # Set heap size
    java -Xms256m -Xmx1024m MyApp
    
    # Choose garbage collector
    java -XX:+UseG1GC MyApp          # G1 Garbage Collector
    java -XX:+UseParallelGC MyApp    # Parallel GC
    java -XX:+UseZGC MyApp           # Z Garbage Collector (Java 11+)
    
    # GC logging
    java -Xlog:gc* MyApp             # Java 9+
    

    ⬆ Back to Top

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

    Java provides several garbage collector implementations, each optimized for different scenarios:

    1. Serial Garbage Collector (-XX:+UseSerialGC)

    • Uses single thread for garbage collection
    • Best for single-threaded applications
    • Causes "stop-the-world" pauses
    • Suitable for small applications with small heaps

    2. Parallel Garbage Collector (-XX:+UseParallelGC)

    • Uses multiple threads for garbage collection
    • Also known as "throughput collector"
    • Default GC in Java 8
    • Good for multi-threaded applications requiring high throughput

    3. G1 Garbage Collector (-XX:+UseG1GC)

    • Divides heap into regions
    • Designed for large heaps (> 4GB)
    • Default GC from Java 9 onwards
    • Balances throughput and latency
    • Predictable pause times

    4. Z Garbage Collector (-XX:+UseZGC)

    • Introduced in Java 11
    • Ultra-low latency (< 10ms pause times)
    • Handles heaps from 8MB to 16TB
    • Concurrent garbage collection

    5. Shenandoah Garbage Collector (-XX:+UseShenandoahGC)

    • Low pause time garbage collector
    • Performs concurrent compaction
    • Available in OpenJDK

    public class GCDemo {
        public static void main(String[] args) {
            // Check current garbage collector
            java.lang.management.GarbageCollectorMXBean gc;
            for (java.lang.management.GarbageCollectorMXBean bean : 
                    java.lang.management.ManagementFactory.getGarbageCollectorMXBeans()) {
                System.out.println("GC Name: " + bean.getName());
                System.out.println("Collection Count: " + bean.getCollectionCount());
                System.out.println("Collection Time: " + bean.getCollectionTime() + "ms");
            }
        }
    }
    

    JVM Options for GC:

    # Serial GC
    java -XX:+UseSerialGC -jar app.jar
    
    # Parallel GC
    java -XX:+UseParallelGC -XX:ParallelGCThreads=4 -jar app.jar
    
    # G1 GC
    java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar app.jar
    
    # ZGC
    java -XX:+UseZGC -jar app.jar
    

    GC Type	Best For	Pause Time	Throughput
    Serial	Small apps	High	Low
    Parallel	Throughput apps	Medium	High
    G1	Large heaps	Low-Medium	Medium-High
    ZGC	Low latency	Very Low	Medium

    ⬆ Back to Top

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

    Both wait() and sleep() are used to pause thread execution, but they have significant differences:

    wait()	sleep()
    Defined in Object class	Defined in Thread class
    Releases the lock/monitor	Does not release the lock
    Must be called from synchronized context	Can be called from anywhere
    Can be woken up by notify()/notifyAll()	Cannot be woken up (except interrupt)
    Used for inter-thread communication	Used for introducing delay
    Instance method	Static method

    public class WaitVsSleep {
        private static final Object lock = new Object();
        
        public static void main(String[] args) {
            // Demonstrating sleep()
            Thread sleepThread = new Thread(() -> {
                System.out.println("Sleep thread starting...");
                try {
                    Thread.sleep(2000);  // Sleeps for 2 seconds
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Sleep thread woke up!");
            });
            
            // Demonstrating wait()
            Thread waitThread = new Thread(() -> {
                synchronized (lock) {
                    System.out.println("Wait thread starting...");
                    try {
                        lock.wait(2000);  // Waits for 2 seconds or until notified
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Wait thread woke up!");
                }
            });
            
            // Notify thread
            Thread notifyThread = new Thread(() -> {
                try {
                    Thread.sleep(1000);  // Wait 1 second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    System.out.println("Notifying...");
                    lock.notify();  // Wakes up the waiting thread
                }
            });
            
            sleepThread.start();
            waitThread.start();
            notifyThread.start();
        }
    }
    

    Key Points:

    • wait() is used for coordination between threads
    • sleep() is used to pause execution for a specific time
    • Always call wait() inside a synchronized block
    • wait() can be interrupted by notify() before timeout

    ⬆ Back to Top

54. What is the difference between notify() and notifyAll()?

    Both notify() and notifyAll() are methods in the Object class used to wake up threads waiting on an object's monitor.

    notify()	notifyAll()
    Wakes up only one waiting thread	Wakes up all waiting threads
    Which thread is woken is not guaranteed	All threads compete for the lock
    More efficient when only one thread needs to proceed	Safer when multiple threads may need the resource
    Can cause thread starvation	No starvation, but more overhead

    public class NotifyVsNotifyAll {
        private static final Object lock = new Object();
        private static boolean resourceAvailable = false;
        
        public static void main(String[] args) throws InterruptedException {
            // Create multiple waiting threads
            for (int i = 1; i <= 3; i++) {
                final int threadNum = i;
                new Thread(() -> {
                    synchronized (lock) {
                        while (!resourceAvailable) {
                            System.out.println("Thread " + threadNum + " waiting...");
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println("Thread " + threadNum + " got the resource!");
                    }
                }).start();
            }
            
            Thread.sleep(1000);  // Let all threads start waiting
            
            // Using notify() - wakes only ONE thread
            synchronized (lock) {
                System.out.println("\nCalling notify()...");
                resourceAvailable = true;
                lock.notify();  // Only one thread wakes up
            }
            
            Thread.sleep(1000);
            
            // Reset and demonstrate notifyAll()
            resourceAvailable = false;
            
            // Create more waiting threads
            for (int i = 4; i <= 6; i++) {
                final int threadNum = i;
                new Thread(() -> {
                    synchronized (lock) {
                        while (!resourceAvailable) {
                            System.out.println("Thread " + threadNum + " waiting...");
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println("Thread " + threadNum + " got the resource!");
                    }
                }).start();
            }
            
            Thread.sleep(1000);
            
            // Using notifyAll() - wakes ALL threads
            synchronized (lock) {
                System.out.println("\nCalling notifyAll()...");
                resourceAvailable = true;
                lock.notifyAll();  // All threads wake up
            }
        }
    }
    

    When to use:

    • Use notify() when only one thread can proceed (e.g., single resource)
    • Use notifyAll() when multiple threads might be able to proceed or when condition varies

    ⬆ Back to Top

55. What is an immutable class and how to create one?

    An immutable class is a class whose instances cannot be modified after creation. Once an object is created, its state remains constant throughout its lifetime.

    Benefits of Immutability:

    • Thread-safe without synchronization
    • Can be safely shared and cached
    • Good for hash keys (hashCode never changes)
    • Easier to reason about

    Rules for Creating Immutable Class:

    1. Declare the class as final
    2. Make all fields private and final
    3. Don't provide setter methods
    4. Initialize all fields via constructor
    5. Perform deep copy for mutable objects
    6. Return copies of mutable objects in getters

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    // Immutable class example
    public final class ImmutablePerson {
        private final String name;
        private final int age;
        private final List<String> hobbies;
        
        public ImmutablePerson(String name, int age, List<String> hobbies) {
            this.name = name;
            this.age = age;
            // Deep copy of mutable object
            this.hobbies = new ArrayList<>(hobbies);
        }
        
        public String getName() {
            return name;
        }
        
        public int getAge() {
            return age;
        }
        
        // Return unmodifiable copy to prevent modification
        public List<String> getHobbies() {
            return Collections.unmodifiableList(hobbies);
        }
        
        // Method that appears to modify but returns new instance
        public ImmutablePerson withAge(int newAge) {
            return new ImmutablePerson(this.name, newAge, this.hobbies);
        }
        
        @Override
        public String toString() {
            return "ImmutablePerson{name='" + name + "', age=" + age + 
                   ", hobbies=" + hobbies + "}";
        }
    }
    
    // Usage
    class ImmutableDemo {
        public static void main(String[] args) {
            List<String> hobbies = new ArrayList<>();
            hobbies.add("Reading");
            hobbies.add("Gaming");
            
            ImmutablePerson person = new ImmutablePerson("John", 25, hobbies);
            System.out.println("Original: " + person);
            
            // Original list modification doesn't affect the object
            hobbies.add("Cooking");
            System.out.println("After modifying original list: " + person);
            
            // Cannot modify returned list
            // person.getHobbies().add("Swimming"); // Throws UnsupportedOperationException
            
            // Create new instance with different age
            ImmutablePerson olderPerson = person.withAge(30);
            System.out.println("New person: " + olderPerson);
            System.out.println("Original unchanged: " + person);
        }
    }
    

    Java Record (Java 14+):

    // Records are immutable by default
    public record Person(String name, int age) {
        // Automatically generates constructor, getters, equals, hashCode, toString
    }
    

    ⬆ Back to Top

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

    All three are used to handle strings in Java, but they have different characteristics:

    Feature	String	StringBuilder	StringBuffer
    Mutability	Immutable	Mutable	Mutable
    Thread Safety	Thread-safe (immutable)	Not thread-safe	Thread-safe (synchronized)
    Performance	Slower for concatenation	Fastest	Slower than StringBuilder
    Storage	String Pool	Heap	Heap
    Since	Java 1.0	Java 1.5	Java 1.0

    public class StringComparison {
        public static void main(String[] args) {
            // String - immutable
            String str = "Hello";
            str = str + " World";  // Creates new String object
            System.out.println("String: " + str);
            
            // StringBuilder - mutable, not thread-safe
            StringBuilder sb = new StringBuilder("Hello");
            sb.append(" World");  // Modifies same object
            System.out.println("StringBuilder: " + sb);
            
            // StringBuffer - mutable, thread-safe
            StringBuffer sbuf = new StringBuffer("Hello");
            sbuf.append(" World");  // Modifies same object
            System.out.println("StringBuffer: " + sbuf);
            
            // Performance comparison
            long startTime, endTime;
            
            // String concatenation (slow)
            startTime = System.currentTimeMillis();
            String s = "";
            for (int i = 0; i < 100000; i++) {
                s += "a";
            }
            endTime = System.currentTimeMillis();
            System.out.println("String time: " + (endTime - startTime) + "ms");
            
            // StringBuilder (fast)
            startTime = System.currentTimeMillis();
            StringBuilder sb2 = new StringBuilder();
            for (int i = 0; i < 100000; i++) {
                sb2.append("a");
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuilder time: " + (endTime - startTime) + "ms");
            
            // StringBuffer (moderate)
            startTime = System.currentTimeMillis();
            StringBuffer sbuf2 = new StringBuffer();
            for (int i = 0; i < 100000; i++) {
                sbuf2.append("a");
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuffer time: " + (endTime - startTime) + "ms");
        }
    }
    

    Common Methods (StringBuilder/StringBuffer):

    StringBuilder sb = new StringBuilder("Hello");
    sb.append(" World");           // Append
    sb.insert(5, ",");             // Insert at position
    sb.delete(5, 6);               // Delete range
    sb.reverse();                  // Reverse
    sb.replace(0, 5, "Hi");        // Replace range
    String result = sb.toString(); // Convert to String
    

    When to use:

    • String: When string won't change much
    • StringBuilder: When string changes frequently (single-threaded)
    • StringBuffer: When string changes frequently (multi-threaded)

    ⬆ Back to Top

57. What is the difference between static and instance variables?

    Static variables belong to the class, while instance variables belong to individual objects.

    Static Variable	Instance Variable
    Belongs to class	Belongs to object
    Single copy shared by all instances	Each instance has its own copy
    Declared with static keyword	Declared without static keyword
    Accessed via class name	Accessed via object reference
    Memory allocated once when class loads	Memory allocated when object is created
    Stored in Method Area	Stored in Heap

    public class Employee {
        // Static variable - shared by all instances
        private static int employeeCount = 0;
        private static String companyName = "TechCorp";
        
        // Instance variables - unique to each instance
        private int id;
        private String name;
        private double salary;
        
        public Employee(String name, double salary) {
            this.name = name;
            this.salary = salary;
            this.id = ++employeeCount;  // Use static counter
        }
        
        // Static method - can only access static members
        public static int getEmployeeCount() {
            return employeeCount;
        }
        
        public static String getCompanyName() {
            return companyName;
        }
        
        // Instance method - can access both static and instance members
        public void displayInfo() {
            System.out.println("ID: " + id);
            System.out.println("Name: " + name);
            System.out.println("Salary: " + salary);
            System.out.println("Company: " + companyName);  // Accessing static
        }
        
        public static void main(String[] args) {
            // Accessing static variable before creating any object
            System.out.println("Company: " + Employee.companyName);
            System.out.println("Initial count: " + Employee.getEmployeeCount());
            
            // Create instances
            Employee emp1 = new Employee("John", 50000);
            Employee emp2 = new Employee("Jane", 60000);
            Employee emp3 = new Employee("Bob", 55000);
            
            // Each has unique instance variables
            emp1.displayInfo();
            System.out.println();
            emp2.displayInfo();
            
            // Static variable is shared
            System.out.println("\nTotal employees: " + Employee.getEmployeeCount());
            
            // Change static variable - affects all
            Employee.companyName = "NewTechCorp";
            System.out.println("\nAfter company name change:");
            emp1.displayInfo();
            emp2.displayInfo();
        }
    }
    

    Static Block:

    class StaticDemo {
        static int value;
        
        // Static block - executed once when class loads
        static {
            System.out.println("Static block executed");
            value = 100;
        }
    }
    

    ⬆ Back to Top

58. What is the purpose of the super keyword?

    The super keyword in Java is used to refer to the immediate parent class. It has three main uses:

    1. Access Parent Class Variables:

    class Animal {
        String name = "Animal";
    }
    
    class Dog extends Animal {
        String name = "Dog";
        
        void displayNames() {
            System.out.println("Child name: " + name);
            System.out.println("Parent name: " + super.name);
        }
    }
    

    2. Call Parent Class Methods:

    class Animal {
        void eat() {
            System.out.println("Animal is eating");
        }
    }
    
    class Dog extends Animal {
        @Override
        void eat() {
            super.eat();  // Call parent method first
            System.out.println("Dog is eating dog food");
        }
    }
    

    3. Call Parent Class Constructor:

    class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    class Employee extends Person {
        String department;
        double salary;
        
        Employee(String name, int age, String department, double salary) {
            super(name, age);  // Call parent constructor (must be first statement)
            this.department = department;
            this.salary = salary;
        }
    }
    

    Complete Example:

    class Vehicle {
        String brand = "Generic";
        int maxSpeed = 100;
        
        Vehicle() {
            System.out.println("Vehicle constructor");
        }
        
        Vehicle(String brand, int maxSpeed) {
            this.brand = brand;
            this.maxSpeed = maxSpeed;
            System.out.println("Vehicle parameterized constructor");
        }
        
        void start() {
            System.out.println("Vehicle starting...");
        }
        
        void displayInfo() {
            System.out.println("Brand: " + brand + ", Max Speed: " + maxSpeed);
        }
    }
    
    class Car extends Vehicle {
        String brand = "Car Brand";  // Hides parent variable
        int numDoors;
        
        Car(String brand, int maxSpeed, int numDoors) {
            super(brand, maxSpeed);  // Call parent constructor
            this.numDoors = numDoors;
            System.out.println("Car constructor");
        }
        
        @Override
        void start() {
            super.start();  // Call parent method
            System.out.println("Car engine started!");
        }
        
        void showBrands() {
            System.out.println("Car brand field: " + brand);
            System.out.println("Parent brand field: " + super.brand);
        }
    }
    
    public class SuperDemo {
        public static void main(String[] args) {
            Car car = new Car("Toyota", 200, 4);
            car.start();
            car.showBrands();
            car.displayInfo();
        }
    }
    

    ⬆ Back to Top

59. What is the purpose of the this keyword?

    The this keyword in Java refers to the current object instance. It has several uses:

    1. Distinguish Instance Variables from Parameters:

    class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;  // this.name refers to instance variable
            this.age = age;    // age (right) is the parameter
        }
    }
    

    2. Call Another Constructor (Constructor Chaining):

    class Employee {
        String name;
        int age;
        String department;
        
        Employee() {
            this("Unknown", 0, "General");  // Call parameterized constructor
        }
        
        Employee(String name) {
            this(name, 0, "General");
        }
        
        Employee(String name, int age, String department) {
            this.name = name;
            this.age = age;
            this.department = department;
        }
    }
    

    3. Pass Current Object as Parameter:

    class Calculator {
        int value;
        
        Calculator(int value) {
            this.value = value;
        }
        
        void display(Calculator calc) {
            System.out.println("Value: " + calc.value);
        }
        
        void show() {
            display(this);  // Pass current object
        }
    }
    

    4. Return Current Object (Method Chaining/Fluent Interface):

    class Builder {
        private String name;
        private int age;
        private String email;
        
        Builder setName(String name) {
            this.name = name;
            return this;  // Return current object for chaining
        }
        
        Builder setAge(int age) {
            this.age = age;
            return this;
        }
        
        Builder setEmail(String email) {
            this.email = email;
            return this;
        }
        
        void build() {
            System.out.println("Name: " + name + ", Age: " + age + ", Email: " + email);
        }
    }
    
    // Usage with method chaining
    class ThisDemo {
        public static void main(String[] args) {
            new Builder()
                .setName("John")
                .setAge(25)
                .setEmail("[email protected]")
                .build();
        }
    }
    

    5. Reference Current Class Instance in Inner Class:

    class Outer {
        int value = 10;
        
        class Inner {
            int value = 20;
            
            void display() {
                int value = 30;
                System.out.println("Local: " + value);
                System.out.println("Inner: " + this.value);
                System.out.println("Outer: " + Outer.this.value);
            }
        }
    }
    

    ⬆ Back to Top

60. What are generics in Java?

    Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. They provide compile-time type safety and eliminate the need for casting.

    Benefits of Generics:

    • Type safety at compile time
    • Elimination of casts
    • Code reusability
    • Enable generic algorithms

    Generic Class:

    // Generic class with type parameter T
    class Box<T> {
        private T content;
        
        public void set(T content) {
            this.content = content;
        }
        
        public T get() {
            return content;
        }
    }
    
    // Multiple type parameters
    class Pair<K, V> {
        private K key;
        private V value;
        
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        
        public K getKey() { return key; }
        public V getValue() { return value; }
    }
    

    Generic Method:

    class Utilities {
        // Generic method
        public static <T> void printArray(T[] array) {
            for (T element : array) {
                System.out.print(element + " ");
            }
            System.out.println();
        }
        
        // Generic method with return type
        public static <T> T getFirst(List<T> list) {
            return list.isEmpty() ? null : list.get(0);
        }
        
        // Multiple type parameters
        public static <K, V> V getValue(Map<K, V> map, K key) {
            return map.get(key);
        }
    }
    

    Bounded Type Parameters:

    // Upper bound - T must extend Number
    class NumberBox<T extends Number> {
        private T number;
        
        public NumberBox(T number) {
            this.number = number;
        }
        
        public double doubleValue() {
            return number.doubleValue();
        }
    }
    
    // Multiple bounds
    class MultiBound<T extends Number & Comparable<T>> {
        private T value;
        
        public int compareTo(T other) {
            return value.compareTo(other);
        }
    }
    

    Wildcards:

    class WildcardDemo {
        // Unbounded wildcard
        public static void printList(List<?> list) {
            for (Object item : list) {
                System.out.println(item);
            }
        }
        
        // Upper bounded wildcard (read-only)
        public static double sumNumbers(List<? extends Number> list) {
            double sum = 0;
            for (Number n : list) {
                sum += n.doubleValue();
            }
            return sum;
        }
        
        // Lower bounded wildcard (write-only)
        public static void addIntegers(List<? super Integer> list) {
            list.add(1);
            list.add(2);
            list.add(3);
        }
    }
    

    Usage Example:

    public class GenericsDemo {
        public static void main(String[] args) {
            // Generic class usage
            Box<String> stringBox = new Box<>();
            stringBox.set("Hello");
            String str = stringBox.get();  // No cast needed
            
            Box<Integer> intBox = new Box<>();
            intBox.set(100);
            int num = intBox.get();
            
            // Pair
            Pair<String, Integer> pair = new Pair<>("Age", 25);
            System.out.println(pair.getKey() + ": " + pair.getValue());
            
            // Generic method
            Integer[] intArray = {1, 2, 3, 4, 5};
            String[] strArray = {"A", "B", "C"};
            Utilities.printArray(intArray);
            Utilities.printArray(strArray);
            
            // Bounded type
            NumberBox<Integer> numBox = new NumberBox<>(42);
            System.out.println("Double value: " + numBox.doubleValue());
        }
    }
    

    ⬆ Back to Top

61. What is type erasure in Java generics?

    Type erasure is the process by which the Java compiler removes all generic type information during compilation. Generic type parameters are replaced with their bounds or Object, and type casts are inserted where necessary.

    How Type Erasure Works:

    // Before compilation (source code)
    public class Box<T> {
        private T content;
        
        public void set(T content) {
            this.content = content;
        }
        
        public T get() {
            return content;
        }
    }
    
    // After type erasure (bytecode equivalent)
    public class Box {
        private Object content;
        
        public void set(Object content) {
            this.content = content;
        }
        
        public Object get() {
            return content;
        }
    }
    

    Bounded Type Erasure:

    // Before erasure
    public class NumberBox<T extends Number> {
        private T number;
        
        public double getValue() {
            return number.doubleValue();
        }
    }
    
    // After erasure - T replaced with Number (its bound)
    public class NumberBox {
        private Number number;
        
        public double getValue() {
            return number.doubleValue();
        }
    }
    

    Bridge Methods: The compiler generates bridge methods to preserve polymorphism:

    class Node<T> {
        public T data;
        
        public void setData(T data) {
            this.data = data;
        }
    }
    
    class IntegerNode extends Node<Integer> {
        @Override
        public void setData(Integer data) {
            System.out.println("IntegerNode.setData");
            super.setData(data);
        }
    }
    
    // Compiler generates bridge method:
    // public void setData(Object data) {
    //     setData((Integer) data);  // Calls the actual method
    // }
    

    Implications of Type Erasure:

    public class TypeErasureDemo {
        public static void main(String[] args) {
            // 1. Cannot create instances of type parameters
            // T obj = new T();  // Compile error
            
            // 2. Cannot create arrays of parameterized types
            // List<String>[] array = new List<String>[10];  // Compile error
            List<?>[] array = new List<?>[10];  // OK with wildcard
            
            // 3. Cannot use instanceof with parameterized types
            List<String> list = new ArrayList<>();
            // if (list instanceof ArrayList<String>) {}  // Compile error
            if (list instanceof ArrayList<?>) {}  // OK with wildcard
            
            // 4. Runtime type is same regardless of type parameter
            List<String> stringList = new ArrayList<>();
            List<Integer> intList = new ArrayList<>();
            System.out.println(stringList.getClass() == intList.getClass());  // true
            
            // 5. Cannot overload methods that have same erasure
            // void process(List<String> list) {}
            // void process(List<Integer> list) {}  // Compile error - same erasure
        }
        
        // Workaround: Use Class<T> for runtime type information
        public static <T> T createInstance(Class<T> clazz) throws Exception {
            return clazz.getDeclaredConstructor().newInstance();
        }
    }
    

    Why Type Erasure?

    • Backward compatibility with pre-generics code
    • No need for new bytecode instructions
    • Reduced memory footprint (no runtime type info)

    Limitations:

    • Cannot determine generic type at runtime
    • Cannot create generic arrays
    • Cannot use primitives as type parameters
    • Cannot catch or throw generic exceptions

    ⬆ Back to Top

62. Can you override a private or static method?

    No, you cannot override private or static methods in Java. These methods are not subject to polymorphism.

    Detailed Explanation:

    1. Private Methods - Cannot Override:

    Private methods are not inherited by subclasses and therefore cannot be overridden. Since private members have class-level scope, they are not accessible in child classes.

    class Parent {
        private void display() {
            System.out.println("Parent's private display");
        }
    }
    
    class Child extends Parent {
        // This is NOT an override - it's a new method in Child class
        public void display() {
            System.out.println("Child's display");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Parent parent = new Child();
            parent.display();  // Calls Parent's private display (not accessible here - compile error)
            
            Child child = new Child();
            child.display();   // Calls Child's display method
        }
    }
    

    In this example, display() in the Child class is a completely new method, not an override. This is called "method hiding" or "shadowing" at the compile level.

    Key Points about Private Methods:

    • Private methods have class-level scope and are not visible outside the class
    • They cannot be inherited by subclasses
    • You can define a method with the same signature in the child class, but it's a new method, not an override
    • The @Override annotation would cause a compile error if used on a private method that shadows a parent's private method

    2. Static Methods - Cannot Override (Method Hiding Instead):

    Static methods belong to the class, not to instances. They cannot be overridden, but they can be "hidden" (redefined) in subclasses. When you call a static method on a reference, it's resolved at compile-time based on the reference type, not the runtime type.

    class Parent {
        static void staticDisplay() {
            System.out.println("Parent's static display");
        }
    }
    
    class Child extends Parent {
        // This is method hiding, not overriding
        static void staticDisplay() {
            System.out.println("Child's static display");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Parent parent = new Child();
            parent.staticDisplay();  // Calls Parent's staticDisplay (resolved at compile-time)
            
            Child child = new Child();
            child.staticDisplay();   // Calls Child's staticDisplay
            
            Parent.staticDisplay();  // Calls Parent's staticDisplay
            Child.staticDisplay();   // Calls Child's staticDisplay
        }
    }
    

    Output:

    Parent's static display
    Child's static display
    Parent's static display
    Child's static display
    

    Notice that even though parent refers to a Child object, calling parent.staticDisplay() invokes the Parent's version because static method resolution happens at compile-time based on the reference type.

    Key Points about Static Methods:

    • Static methods are resolved at compile-time based on the reference type
    • Static methods are not polymorphic
    • When a child class has a static method with the same signature as the parent, it "hides" the parent's method
    • This is different from overriding because the determination of which method to call is made at compile-time, not runtime

    3. Comparison with Public/Protected Instance Methods:

    class Parent {
        public void instanceMethod() {
            System.out.println("Parent's instance method");
        }
    }
    
    class Child extends Parent {
        @Override  // This annotation works correctly
        public void instanceMethod() {
            System.out.println("Child's instance method");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Parent parent = new Child();
            parent.instanceMethod();  // Calls Child's instanceMethod (resolved at runtime)
        }
    }
    

    Output:

    Child's instance method
    

    Here, the method is resolved at runtime based on the actual object type (Child), demonstrating true overriding with polymorphism.

    4. Why This Design?

    • Private Methods: Since they have class scope, inheritance doesn't apply. They're implementation details of a class.
    • Static Methods: Since they belong to the class (not to instances), they don't participate in polymorphic behavior, which is based on instance types.

    Table Summary:

    Method Type	Can Override?	Resolution Time	Behavior
    Public Instance	Yes	Runtime (Polymorphic)	Method overriding with dynamic dispatch
    Protected Instance	Yes	Runtime (Polymorphic)	Method overriding with dynamic dispatch
    Private	No	Compile-time	Method hiding; new method in child class
    Static	No	Compile-time	Method hiding; resolved based on reference type

    ⬆ Back to Top

63. What are common pitfalls with equals() and hashCode() methods?

    The equals() and hashCode() methods are fundamental to how Java handles object comparison and hash-based collections. Incorrectly implementing them leads to subtle and hard-to-debug issues. Below are the most common pitfalls:

    1. Overriding equals() without overriding hashCode()

    This is the most common mistake. The contract states: if two objects are equal according to equals(), they must have the same hashCode(). Violating this breaks hash-based collections like HashMap, HashSet, and Hashtable.

    public class Employee {
        private int id;
        private String name;
    
        public Employee(int id, String name) {
            this.id = id;
            this.name = name;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Employee other = (Employee) obj;
            return id == other.id && Objects.equals(name, other.name);
        }
    
        // hashCode() is NOT overridden!
    }
    
    public class Test {
        public static void main(String[] args) {
            Employee e1 = new Employee(1, "John");
            Employee e2 = new Employee(1, "John");
    
            System.out.println(e1.equals(e2)); // true
    
            Set<Employee> set = new HashSet<>();
            set.add(e1);
            set.add(e2);
            System.out.println(set.size()); // 2 (Expected 1, since they are "equal")
    
            Map<Employee, String> map = new HashMap<>();
            map.put(e1, "Developer");
            System.out.println(map.get(e2)); // null (Expected "Developer")
        }
    }
    

    Since hashCode() is not overridden, e1 and e2 get different hash codes (from Object.hashCode()), so the HashSet treats them as different objects and HashMap cannot find the value using e2.

    2. Using mutable fields in hashCode()

    If mutable fields used in hashCode() are modified after the object is placed in a hash-based collection, the object becomes "lost" — it can no longer be found because its hash bucket has changed.

    public class Employee {
        private int id;
        private String name;
    
        public Employee(int id, String name) {
            this.id = id;
            this.name = name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Employee other = (Employee) obj;
            return id == other.id && Objects.equals(name, other.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(id, name);
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Employee e1 = new Employee(1, "John");
    
            Set<Employee> set = new HashSet<>();
            set.add(e1);
    
            System.out.println(set.contains(e1)); // true
    
            e1.setName("Jane"); // Mutating a field used in hashCode()
    
            System.out.println(set.contains(e1)); // false! Object is "lost"
            System.out.println(set.size());        // 1 (still in the set, but unreachable)
        }
    }
    

    3. Using instanceof instead of getClass() (breaking symmetry in inheritance)

    Using instanceof in equals() can break the symmetry contract (a.equals(b) must equal b.equals(a)) when subclasses are involved.

    public class Animal {
        private String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Animal) { // Uses instanceof
                return name.equals(((Animal) obj).name);
            }
            return false;
        }
    }
    
    public class Dog extends Animal {
        private String breed;
    
        public Dog(String name, String breed) {
            super(name);
            this.breed = breed;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Dog) { // Uses instanceof
                Dog other = (Dog) obj;
                return super.equals(other) && breed.equals(other.breed);
            }
            return false;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Animal a = new Animal("Buddy");
            Dog d = new Dog("Buddy", "Labrador");
    
            System.out.println(a.equals(d)); // true  (Dog is an instance of Animal)
            System.out.println(d.equals(a)); // false (Animal is NOT an instance of Dog)
            // Symmetry is broken!
        }
    }
    

    Use getClass() comparison instead to ensure both objects are of the exact same type.

    4. Not handling null and self-comparison in equals()

    Forgetting to handle null check leads to NullPointerException, and skipping the self-reference check (this == obj) misses an easy optimization.

    // Incorrect implementation
    @Override
    public boolean equals(Object obj) {
        Employee other = (Employee) obj; // Crashes if obj is null!
        return id == other.id && name.equals(other.name);
    }
    
    // Correct implementation
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;                              // Self-check
        if (obj == null || getClass() != obj.getClass()) return false; // Null & type check
        Employee other = (Employee) obj;
        return id == other.id && Objects.equals(name, other.name); // Null-safe comparison
    }
    

    5. Using equals(ClassName obj) instead of equals(Object obj) — overloading instead of overriding

    A very common mistake is changing the parameter type from Object to a specific class. This overloads equals() instead of overriding it, so polymorphic calls (e.g., from collections) still use Object.equals().

    public class Employee {
        private int id;
    
        public Employee(int id) {
            this.id = id;
        }
    
        // This is OVERLOADING, not overriding!
        public boolean equals(Employee other) {
            return this.id == other.id;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Employee e1 = new Employee(1);
            Employee e2 = new Employee(1);
    
            System.out.println(e1.equals(e2)); // true (calls overloaded method)
    
            Object obj = new Employee(1);
            System.out.println(e1.equals(obj)); // false! (calls Object.equals, uses reference comparison)
    
            Set<Employee> set = new HashSet<>();
            set.add(e1);
            set.add(e2);
            System.out.println(set.size()); // 2 (Expected 1)
        }
    }
    

    Always use @Override annotation to let the compiler catch this mistake.

    6. Inconsistent equals() and hashCode() — using different fields

    The fields used in equals() and hashCode() must be consistent. If equals() uses id and name but hashCode() only uses id, two objects that differ only in name will have the same hash code but won't be equal — this is allowed but causes performance degradation due to hash collisions. The opposite (more fields in hashCode() than equals()) breaks the contract.

    public class Employee {
        private int id;
        private String name;
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Employee other = (Employee) obj;
            return id == other.id; // Only uses id
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(id, name); // Uses id AND name — BROKEN!
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Employee e1 = new Employee(1, "John");
            Employee e2 = new Employee(1, "Jane");
    
            System.out.println(e1.equals(e2)); // true (same id)
            System.out.println(e1.hashCode() == e2.hashCode()); // false! Contract violated
        }
    }
    

    Best Practices Summary:

    Pitfall	Consequence	Fix
    Override equals() without hashCode()	Hash-based collections break	Always override both together
    Mutable fields in hashCode()	Objects become unreachable in collections	Use only immutable fields
    instanceof in equals() with inheritance	Breaks symmetry contract	Use getClass() comparison
    Missing null/self checks	NullPointerException or poor performance	Always add null and self checks
    Overloading instead of overriding equals()	Collections use Object.equals()	Use equals(Object obj) with @Override
    Inconsistent fields in equals() and hashCode()	Violates the equals-hashCode contract	Use the same fields in both methods

    ⬆ Back to Top