Java common questions

Key Differences

Example

public class PrimitiveVsObject {
    int instancePrimitiveInt; // Default value 0
    String instanceObjectString; // Default value null

    public static void main(String[] args) {
        // Primitive types
        int localPrimitiveInt = 10;          // Stores the value 10
        double localPrimitiveDouble = 20.5;  // Stores the value 20.5
        boolean localPrimitiveBoolean = true; // Stores the value true
        char localPrimitiveChar = 'A';       // Stores the character 'A'

        // int uninitializedLocalPrimitive;
        // System.out.println(uninitializedLocalPrimitive); // COMPILE ERROR: variable might not have been initialized

        System.out.println("Primitive int: " + localPrimitiveInt);
        // localPrimitiveInt.toString(); // ERROR! Primitives don't have methods

        // Objects
        String objString1 = "Hello"; // objString1 stores a reference to "Hello" object on the heap
        String objString2 = new String("World"); // objString2 stores a reference to a new "World" object

        // String uninitializedLocalObject;
        // System.out.println(uninitializedLocalObject.length()); // COMPILE ERROR: variable might not have been initialized (and then NPE if it was null)

        String nullString = null;
        // System.out.println(nullString.length()); // RUNTIME ERROR: NullPointerException

        System.out.println("Object String 1: " + objString1);
        System.out.println("Length of String 1: " + objString1.length()); // Objects have methods

        PrimitiveVsObject pvo = new PrimitiveVsObject();
        System.out.println("Instance primitive int default: " + pvo.instancePrimitiveInt);
        System.out.println("Instance object String default: " + pvo.instanceObjectString);
    }
}

4. Wrapper classes (Integer, String) vs Primitive types (int, String)

This

question
• mixes two concepts slightly. Integer is a wrapper class for the primitive int.Correction: String is always an object type,object, not a primitive,primitive. andThe not a wrapper for a primitive in the same way Integer is. charcomparison is the primitive for character data.

  Let's addressusually Integer vs int,. and

then
• briefly touch upon String.

  Wrapper Classesclasses (e.g., Integer, Boolean): vsObject representations of primitive types. Can be null. Used in collections (which can only store objects). Provide utility methods.

• Primitive types (e.g., int),
  • Primitive Type (intboolean):
    Direct
    • Asvalue describedtypes. above: stores actual value, no methods, cannotCannot be null,. moreMore efficient.memory and performance efficient for simple operations.
    • String: Is always an object type in Java, immutable. It's not a primitive.

  • WrapperArray Classvs (Integer):List

    • An object that "wraps" or encapsulates a primitive value. java.lang package provides wrapper classes for all primitives: Byte, Short, Integer, Long, Float, Double, Character, Boolean.
    • Purpose:
      1. To use primitive values in contexts where objects are required (e.g., Java Collections like ArrayList<Integer>, Generics).
      2. To provide utility methods related to the primitive type (e.g., Integer.parseInt(), Integer.MAX_VALUE).
      3. To allow primitive values to be null.
    • Behavior: Instances of wrapper classes are objects, so they are stored on the heap, can be null, and have methods.

  String

  • String is an Object Type:Array: It's a class (java.lang.String) representing a sequence of characters. It is not a primitive type.
  • Immutable: String objects are immutable in Java. Once created, their value cannot be changed.
  • Special Treatment: Java provides special support for strings, such as the string pool (for string literals) and the + operator for concatenation.
  • Not a Wrapper for a Primitive: While it deals with character data, it doesn't "wrap" a single primitive char in the same way Integer wraps int. An array of char (char[]) is closer to the rawFixed-size data thatstructure. String manages.

  Key Differences (int vs Integer)

  primitivesor

  Feature	int (Primitive)	Integer (Wrapper Object)
  Nature	Primitive data type	Object (instance of java.lang.Integer)
  Storage	Actual value	Reference to an object on the heap
  null	Cannot be null	Can bestore null
  Methods	No methods	Has methods (e.g., intValue(), compareTo())
  Collections	Cannot be directly used in collections like ArrayList (before Java 5 without autoboxing)	Can be used in collections (ArrayList<Integer>)
  Performance	Generally faster, less memory overhead	Slower, more memory overhead
  Default Value	0 (if instance/static variable)	null (if instance/static variable)

  Example

  import java.util.ArrayList;
  import java.util.List;
  
  public class WrapperVsPrimitive {
      public static void main(String[] args) {
          // int (primitive) vs Integer (wrapper object)
          int primitiveInt = 100;
          Integer wrapperInt = Integer.valueOf(100); // Explicit boxing (older way)
          Integer autoBoxedInt = 100; // Autoboxing (Java 5+)
  
          System.out.println("Primitive int: " + primitiveInt);
          System.out.println("Wrapper Integer: " + wrapperInt);
          System.out.println("Autoboxed Integer: " + autoBoxedInt);
  
          // primitiveInt.compareTo(200); // ERROR: int has no methods
          System.out.println("Compare wrapperInt to 200: " + wrapperInt.compareTo(200)); // -1
  
          Integer nullInteger = null;
          // int anotherPrimitive = nullInteger; // This would cause NullPointerException if unboxing is attempted
  
          List<Integer> numberList = new ArrayList<>();
          numberList.add(primitiveInt); // Autoboxing: int to Integer
          numberList.add(wrapperInt);
          // List<int> primitiveList = new ArrayList<>(); // ERROR: Generic types must be reference types
  
          int unboxedInt = wrapperInt; // Auto-unboxing: Integer to int
  
          // String (Object)
          String strLiteral = "Java"; // String literal, often from string pool
          String strObject = new String("Java"); // Explicitly creates a new String object on heap
  
          char[] charArray = {'J', 'a', 'v', 'a'}; // Primitive char array
          String strFromChars = new String(charArray);
  
          System.out.println("String literal: " + strLiteral);
          System.out.println("String object: " + strObject);
          System.out.println("String from char array: " + strFromChars);
  
          // strLiteral is an object, it has methods
          System.out.println("Length of strLiteral: " + strLiteral.length());
      }
  }
  

  ---

  5. Array vs List

  Array

  • Definition: A fixed-size, ordered collection of elementsobjects of the same data type. TheBasic, typelanguage-level canfeature.
  be
  • primitiveList (Interface): Part of the Java Collections Framework (e.g., int[]) or object (e.g., String[], MyObject[]).
  • Size: Fixed at the time of creation. Cannot be changed dynamically.
  • Type Safety: Strong type checking at compile time. An int[] can only hold ints.
  • Performance: Generally faster for element access (using index) if the index is known, due to direct memory access.
  • Features: Basic operations provided by language syntax (e.g., array[index], array.length). No built-in methods for common data manipulations like add, remove (except by creating a new array).
  • Generics: Cannot be used directly with generics in the way collections can (e.g., you can't have Array<T>).

  List (Interface)

  • Definition: An interface (java.util.List) representing an ordered collection of elements (also known as a sequence). Allows duplicate elements.
  • Implementations: Common implementations include ArrayList, LinkedList,). Vector,Dynamically Stack.resizable. Stores only objects. Offers more methods and flexibility.

• Size:Set vs List

  Dynamic. Lists can grow or shrink as elements are added or removed.
• TypeSet Safety:(Interface): UsesCollection genericsthat fordoes typenot safetyallow duplicate elements. Order is not guaranteed (e.g., List<String>HashSet,) or can be based on insertion (List<Integer>LinkedHashSet) or natural/custom sorting (TreeSet).
• Performance: Varies by implementation. ArrayList is generally fast for random access, while LinkedList is faster for insertions/deletions in the middle.
• Features: Rich set of methods for adding, removing, searching, iterating, sorting, etc. (e.g., add(), remove(), get(), size(), isEmpty()).
• Generics: Designed to work with generics.

Key Differences

Feature	Array	List (Interface)
Size	Fixed, determined at creation	Dynamic, can change
Type	Can hold primitives or objects	Can only hold objects (primitives are autoboxed)
Mutability	Size is immutable	Size is mutable
Methods	Limited (e.g., length property)	Rich API (e.g., add, remove, size)
Performance	Fast direct access by index	Varies by implementation (ArrayList good for access, LinkedList for middle ops)
Generics	Limited support	Full generic support
Implementation	Language construct	Interface with multiple implementations

Example

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayVsListExample {
    public static void main(String[] args) {
        // --- Array ---
        System.out.println("--- Array ---");
        // Declaration and initialization
        String[] stringArray = new String[3]; // Fixed size of 3
        stringArray[0] = "Apple";
        stringArray[1] = "Banana";
        stringArray[2] = "Cherry";
        // stringArray[3] = "Date"; // ArrayIndexOutOfBoundsException

        System.out.println("Array size: " + stringArray.length);
        System.out.println("Element at index 1: " + stringArray[1]);

        // Iterating an array
        for (String fruit : stringArray) {
            System.out.println(fruit);
        }

        int[] intArray = {1, 2, 3, 4, 5}; // Array of primitives
        System.out.println("Int Array: " + Arrays.toString(intArray));


        // --- List ---
        System.out.println("\n--- List (ArrayList implementation) ---");
        // Declaration and initialization (using ArrayList)
        List<String> stringList = new ArrayList<>(); // Dynamic size
        stringList.add("Dog");
        stringList.add("Cat");
        stringList.add("Elephant");

        System.out.println("List size: " + stringList.size());
        System.out.println("Element at index 1: " + stringList.get(1));

        stringList.add("Fish"); // Size dynamically increases
        System.out.println("New list size: " + stringList.size());
        System.out.println("List elements: " + stringList);

        stringList.remove("Cat");
        System.out.println("After removing Cat: " + stringList);

        // List of Integers (uses wrapper class)
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10); // Autoboxing: int to Integer
        integerList.add(20);
        System.out.println("Integer List: " + integerList);
    }
}

---

6. Set vs List

Both Set and List are interfaces in the Java Collections Framework, extending Collection.

List

• Definition: An orderedOrdered collection ofthat elements. Allowsallows duplicate elements.
• Order: Maintains the insertion order of elements (or can be sorted explicitly). Elements can beare accessed by their integer index (position).
• Duplicates: Allows duplicate elements. You can add the same element multiple times.
• Common Implementations: ArrayList, LinkedList, Vector.
• Use Case: When the order of elements matters, and duplicates are acceptable. E.g., a list of steps in a recipe, a sequence of user actions.

Set

• Definition: A collection that contains no duplicate elements.
• Order:
  • HashSet: Makes no guarantees as to the iteration order of the set; it may even change over time.
  • LinkedHashSet: Maintains insertion order.
  • TreeSet: Stores elements in a sorted order (natural order or by a Comparator).index.

• Duplicates: Does not allow duplicate elements. If you try to add an element that is already present (according to its equals() method), the add() method returns false and the set remains unchanged.

• Common Implementations: HashSet, LinkedHashSet, TreeSet.
• Use Case: When you need to store unique items, and the primary concern is checking for the existence of an item. E.g., a collection of unique visitors to a website, distinct words in a document.

Key Differences

Feature	List	Set
Order	Ordered (maintains insertion order or sorted)	Generally unordered (HashSet), or ordered (LinkedHashSet, TreeSet)
Duplicates	Allows duplicate elements	Does not allow duplicate elements
Element Access	Positional access using get(index)	No direct get(index) (except by iteration or converting to List)
add() method	Adds element, usually returns true	Adds element if not present, returns true if added, false if already present
Primary Use	Ordered sequences, allowing duplicates	Collections of unique items
Implementations	ArrayList, LinkedList	HashSet, LinkedHashSet, TreeSet

Example

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public class SetVsListExample {
    public static void main(String[] args) {
        // --- List Example (ArrayList) ---
        System.out.println("--- List (ArrayList) ---");
        List<String> fruitList = new ArrayList<>();
        fruitList.add("Apple");
        fruitList.add("Banana");
        fruitList.add("Apple"); // Duplicate allowed
        fruitList.add("Orange");

        System.out.println("Fruit List: " + fruitList); // Order is maintained
        System.out.println("Element at index 0: " + fruitList.get(0)); // Access by index

        // --- Set Examples ---
        System.out.println("\n--- Set (HashSet - unordered) ---");
        Set<String> fruitHashSet = new HashSet<>();
        System.out.println("Added Apple: " + fruitHashSet.add("Apple"));
        System.out.println("Added Banana: " + fruitHashSet.add("Banana"));
        System.out.println("Added Apple again: " + fruitHashSet.add("Apple")); // Duplicate not added, returns false
        System.out.println("Added Orange: " + fruitHashSet.add("Orange"));

        System.out.println("Fruit HashSet: " + fruitHashSet); // Order not guaranteed, no duplicates
        // fruitHashSet.get(0); // COMPILE ERROR: No get(index) method

        System.out.println("\n--- Set (LinkedHashSet - insertion order) ---");
        Set<String> fruitLinkedHashSet = new LinkedHashSet<>();
        fruitLinkedHashSet.add("Apple");
        fruitLinkedHashSet.add("Banana");
        fruitLinkedHashSet.add("Apple"); // Duplicate not added
        fruitLinkedHashSet.add("Orange");
        fruitLinkedHashSet.add("Grape");

        System.out.println("Fruit LinkedHashSet: " + fruitLinkedHashSet); // Insertion order maintained, no duplicates

        System.out.println("\n--- Set (TreeSet - sorted order) ---");
        Set<String> fruitTreeSet = new TreeSet<>();
        fruitTreeSet.add("Orange");
        fruitTreeSet.add("Apple");
        fruitTreeSet.add("Banana");
        fruitTreeSet.add("Apple"); // Duplicate not added
        fruitTreeSet.add("Grape");

        System.out.println("Fruit TreeSet: " + fruitTreeSet); // Sorted order (natural string order), no duplicates
    }
}

---

7. Comparable vs Comparator

Both are interfaces in Java used for sorting objects.

Comparable<T>

• Definition:Comparable (Interface): AnImplemented interface (java.lang.Comparable) thatby a class can implement to define its "natural ordering."ordering. Has one method: compareTo(). The class itself decides how its instances should be sorted.
• Method:Comparator (Interface): ItImplemented hasas a singleseparate class to define custom or multiple orderings for objects of another class. Has one main method: int compareTo(T o)compare().
  Useful
  • Returnswhen ayou negativecan't integermodify ifthe thisclass objector isneed lessdifferent thansorting o.
  • Returns zero if this object is equal to o.
  • Returns a positive integer if this object is greater than o.criteria.

• Usage:

  • Implemented by the class whose instances you want to sort.
  • Used by sorting methods like Collections.sort(List<T>) and Arrays.sort(T[]) by default if no Comparator is provided.
  • Data structures like TreeSet and TreeMap use the natural ordering if no Comparator is specified.
• Modification: Requires modifying the source code of the class itself.
• Ordering: Provides a single way of sorting (the natural order).

Comparator<T>

• Definition: An interface (java.util.Comparator) that can be implemented to define custom or multiple sorting orders for objects of a class.
• Method: It has a primary method: int compare(T o1, T o2).
  • Returns a negative integer if o1 is less than o2.
  • Returns zero if o1 is equal to o2.
  • Returns a positive integer if o1 is greater than o2.
  • (Also has other default/static methods like thenComparing, reversed, etc., since Java 8).
• Usage:
  • Implemented in a separate class, or as an anonymous class, or a lambda expression.
  • Passed as an argument to sorting methods (e.g., Collections.sort(List<T>, Comparator<T>), Arrays.sort(T[], Comparator<T>)).
  • Can be provided to constructors of TreeSet and TreeMap to define a specific order.
• Modification: Does not require modifying the source code of the class being sorted.
• Ordering: Allows defining multiple, different sorting strategies for the same class.

Key Differences

Feature	Comparable<T>	Comparator<T>
Package	java.lang	java.util
Method	compareTo(T o)	compare(T o1, T o2)
Implementation	Implemented by the class itself	Implemented in a separate class/lambda
Purpose	Defines natural ordering of objects	Defines custom/alternative ordering of objects
Modification	Requires changing the class being sorted	Does not require changing the class being sorted
Flexibility	Provides one sorting logic (natural order)	Provides multiple sorting logics
Usage	Collections.sort(list) uses it by default	Passed as an argument to Collections.sort(list, comparator)

Example

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

// Class implementing Comparable for natural ordering (by age)
class Person implements Comparable<Person> {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        // Natural ordering: by age
        return Integer.compare(this.age, other.age);
        // If this.age < other.age, returns negative
        // If this.age == other.age, returns zero
        // If this.age > other.age, returns positive
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

// Comparator for sorting Person objects by name
class PersonNameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.name.compareTo(p2.name);
    }
}

public class ComparableComparatorExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));
        people.add(new Person("Diana", 25));

        System.out.println("Original list: " + people);

        // 1. Sorting using Comparable (natural order: by age)
        Collections.sort(people); // Uses Person's compareTo() method
        System.out.println("Sorted by age (Comparable): " + people);

        // Reset list for next sort
        people.clear();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));
        people.add(new Person("Diana", 25));


        // 2. Sorting using Comparator (custom order: by name)
        Collections.sort(people, new PersonNameComparator());
        System.out.println("Sorted by name (Comparator): " + people);

        // 3. Sorting using Comparator (lambda expression for reverse age order)
        // No need to reset list, just re-sort
        Comparator<Person> reverseAgeComparator = (p1, p2) -> Integer.compare(p2.age, p1.age);
        // Or use Java 8 Comparator helpers:
        // Comparator<Person> reverseAgeComparator = Comparator.comparingInt((Person p) -> p.age).reversed();

        Collections.sort(people, reverseAgeComparator);
        System.out.println("Sorted by age descending (Lambda Comparator): " + people);

        // 4. Sorting by name then by age (if names are same)
        Comparator<Person> nameThenAgeComparator = Comparator
            .comparing((Person p) -> p.name)
            .thenComparingInt(p -> p.age);
        Collections.sort(people, nameThenAgeComparator);
        System.out.println("Sorted by name then age: " + people);
    }
}

---

8. Interface vs Abstract class

Both are mechanisms for abstraction in Java, but they have different characteristics and use cases.

Interface

• Definition:Interface: A blueprintcontract ofspecifying methods a class. It specifies a contract that implementing classesclass must adhereimplement. to.
• Methods:
  • Traditionally, interfaces could onlyCannot have publicinstance abstract methodsvariables (method signatures without implementation) andonly public static final constants.
  constants).
  • JavaCan 8 addedhave public default methods (with implementation, can be overridden) and public static methods (with implementation, cannot be overridden by implementing classes).
  • Java 9 added private and private static methods (helper methods for default/static methods within the interface)8+).
• Variables: Can only declare public static final variables (constants). Instance variables are not allowed.
• Constructors: Cannot have constructors. Cannot be instantiated directly.
• Implementation: A class implements an interface. A class can implement multiple interfacesinterfaces. (multipleDefines inheritance"what" ofa type).class can do.
• AccessAbstract Modifiers:class: All members are implicitly public. Methods are implicitly abstract (unless default or static).
• Purpose: To define a contract, achieve multiple inheritance of type, achieve loose coupling. Good for defining capabilities (e.g., Serializable, Runnable, Flyable).

Abstract Class

• Definition: A class that cannotCannot be instantiated directly and is meant to be subclassed. It can provide a partial implementation of a class.
• Methods:instantiated. Can have abstract methods (no implementation)unimplemented) and concrete methods (with implementation). Can also have static and finalimplemented) methods.
• Variables: Can have instance variables (non-static) and static variables. They can have any access modifier (public, protected, private, default). Can also be final.
• Constructors: Can have constructors. These are called when an instance of a concrete subclass is created (usually via super() call from subclass constructor).
• Implementation: A class extends an abstract class. A class can extend only one abstract classclass. (or any class).
• Access Modifiers: Members can have any access modifier.
• Purpose: To provideProvides a common base class with some sharedcommon code and some parts that subclasses must implement. Goodfunctionality for "is-a" relationships where subclasses share common state and behavior.

Key Differences

Feature	Interface	Abstract Class
Multiple Inheritance	A class can implement multiple interfaces.	A class can extend only one abstract class.
Methods	Abstract, default, static, private methods.	Abstract and concrete methods. Can be static, final.
Variables	Only public static final constants.	Instance variables, static variables, constants. Any access modifier.
Constructors	No constructors.	Can have constructors.
Implementation Detail	Focuses on "what" a class can do (contract).	Can provide some "how" (partial implementation).
Keyword	interface, implements	abstract class, extends
State	Cannot have instance state (non-final variables).	Can have instance state (instance variables).
Use Case	Defining capabilities, API contracts, mixins (with default methods).	Code reuse, common base for related classes.
Access Modifiers	Implicitly public for members.	Members can have any access modifier.

Example

// --- Interface ---
interface Playable {
    // public static final String TYPE = "Playable"; // Implicitly public static final
    String TYPE = "Playable"; // Same as above

    void play(); // Implicitly public abstract

    default void displayType() { // Default method (Java 8+)
        System.out.println("This is of type: " + TYPE);
    }

    static String getCategory() { // Static method (Java 8+)
        return "Entertainment";
    }
}

interface Recordable {
    void record();
    void stopRecording();
}

// --- Abstract Class ---
abstract class MediaDevice {
    protected String deviceName; // Instance variable (can be protected, private, etc.)
    private boolean powerOn;     // Instance variable

    public MediaDevice(String deviceName) { // Constructor
        this.deviceName = deviceName;
        this.powerOn = false;
        System.out.println(deviceName + " device created.");
    }

    public void powerOn() { // Concrete method
        this.powerOn = true;
        System.out.println(deviceName + " powered ON.");
    }

    public void powerOff() { // Concrete method
        this.powerOn = false;
        System.out.println(deviceName + " powered OFF.");
    }

    public boolean isPoweredOn() {
        return powerOn;
    }

    public abstract void showStatus(); // Abstract method - must be implemented by subclasses
}

// --- Concrete Class ---
// Implements multiple interfaces and extends one abstract class
class SmartSpeaker extends MediaDevice implements Playable, Recordable {
    public SmartSpeaker(String name) {
        super(name); // Call superclass constructor
    }

    @Override
    public void play() {
        if (isPoweredOn()) {
            System.out.println(deviceName + " is playing music.");
        } else {
            System.out.println(deviceName + " is off. Cannot play.");
        }
    }

    @Override
    public void record() {
        if (isPoweredOn()) {
            System.out.println(deviceName + " is recording audio.");
        } else {
            System.out.println(deviceName + " is off. Cannot record.");
        }
    }

    @Override
    public void stopRecording() {
         if (isPoweredOn()) {
            System.out.println(deviceName + " stopped recording.");
        }
    }

    @Override
    public void showStatus() {
        System.out.println("Status for " + deviceName + ": Power " + (isPoweredOn() ? "ON" : "OFF"));
    }
}

public class InterfaceAbstractExample {
    public static void main(String[] args) {
        SmartSpeaker alexa = new SmartSpeaker("Alexa Echo");

        alexa.powerOn();
        alexa.showStatus();

        alexa.play();       // From Playable interface
        alexa.record();     // From Recordable interface
        alexa.stopRecording();

        alexa.displayType(); // Default method from Playable interface
        System.out.println("Category: " + Playable.getCategory()); // Static method from Playable

        alexa.powerOff();
        alexa.showStatus();
        alexa.play();
    }
}

---

9. Final vs Static keyword

These keywords serve very different purposes in Java.

final keyword

The final keyword can be applied to variables, methods, and classes. Its meaning changes based on context.

• final variable:
  • Primitive: The value of the variable cannot be changed once assigned. It becomes a constant. Must be initialized at declaration or in the constructor (if it's an instance variable).
  • Object Reference: The reference variable cannot be reassigned to point to a different object. However, the state of the object it points to can be changed (if the object itself is mutable).relationships.

• finalFinal method:vs Static keyword

  • Final:
    • AVariable: final methodValue cannot be changed after initialization (constant).
    • Method: Cannot be overridden by subclasses.
    • UsedClass: toCannot preventbe subclassessubclassed from(inherited altering critical behavior.from).
  • final class:Static:
    • AVariable: finalClass-level class cannot be subclassed (extended).
    • E.g., String, Integer are final classes.
    • Used for security or to ensure the immutability or specific behavior of the class cannot be compromised by subclassing.

  static keyword

  The static keyword indicates that a member (variable or method) or a nested class belongs to the class itself, rather than to instances of the class.

  • static variable (class variable):
    • There is only one copy of the static variablevariable, shared among all instances of the class.
    • ItMethod: isClass-level initializedmethod, when the class is loaded.
    • Can be accessed using ClassName.variableName.
  • static method (class method):
    • Cancan be called without creating an instance of the class (ClassName.methodName()).class.
    • CanBlock: only access static variables and call other static methods directly.
    • Cannot use this or super.
  • static block:
    • A block of code that is executedExecuted once when the class is loaded into memory. Used for static initialization.
    loaded.
  • Nested static nested class:
    • A nested class declared static. It does not have an implicit reference to an instance of the outer class. It can only access static members of the outer class directly.Class: Can be instantiated without an instance of the outer class.

• KeyThey Differences

  are orthogonalconceptsand

  Feature	final	static
  Purpose	To restrict modification/extension/overriding. Creates constants.	To associate a member with the class rather than an instance. Shared memory.
  Applicable to	Variables, methods, classes.	Variables, methods, blocks, nested classes.
  Variables	Value cannotcan be changedused (for primitives); reference cannot be changed (for objects).	Single copy shared by all instances. Belongs to the class.
  Methods	Cannot be overridden.	Belongs to the class, called via ClassName.method(). No this.
  Classes	Cannot be subclassed.	(For nested classes) Does not hold reference to outer class instance.
  Memory	Does not directly impact memory model like static (except making references unchangeable).	Static members are stored in a separate memory areatogether (e.g., method area/metaspace).

  Example

  class MyMath {
      // final variable (constant)
      public static final double PI = 3.14159; // 'static final' makes it a class constant
  
      // instance variable (can be final)
      private final int id; // Must be initialized in constructor or at declaration
      private String instanceName;
  
      // static variable
      private static int instanceCount = 0;
  
      public MyMath(int id, String name) {
          this.id = id; // Initialize final instance variable
          this.instanceName = name;
          instanceCount++;
      }
  
      // final method (cannot be overridden)
      public final void printID() {
          System.out.println("ID: " + this.id);
      }
  
      // instance method
      public void printName() {
          System.out.println("Name: " + this.instanceName);
      }
  
      // static method
      public static int getInstanceCount() {
          // System.out.println(instanceName); // ERROR: Cannot access instance variable from static context
          // printName(); // ERROR: Cannot call instance method from static context
          return instanceCount;
      }
  
      // static block
      static {
          System.out.println("MyMath class loaded. Initial instance count: " + instanceCount);
          // PI = 3.14; // Can initialize static final here if not at declaration
      }
  }
  
  // final class (cannot be extended)
  final class ImmutablePoint {
      private final int x;
      private final int y;
  
      public ImmutablePoint(int x, int y) {
          this.x = x;
          this.y = y;
      }
  
      public int getX() { return x; }
      public int getY() { return y; }
  }
  
  // class TryingToExtend extends ImmutablePoint {} // ERROR: Cannot inherit from final ImmutablePoint
  
  class AdvancedMath extends MyMath {
      public AdvancedMath(int id, String name) {
          super(id, name);
      }
  
      // @Override
      // public final void printID() { // ERROR: Cannot override final method from MyMath
      //     System.out.println("Advanced ID: " + super.id); // 'id' is private, but can be accessed if it were protected
      // }
  
      @Override
      public void printName() { // OK to override non-final method
          System.out.print("Advanced Math - ");
          super.printName();
      }
  }
  
  
  public class FinalStaticExample {
      public static void main(String[] args) {
          System.out.println("Accessing static final constant: MyMath.PIMY_CONSTANT = "value";)
  + MyMath.PI);
          // MyMath.PI = 3.0; // ERROR: Cannot assign a value to final variable PI
  
          System.out.println("Initial instance count (static method): " + MyMath.getInstanceCount()); // 0
  
          MyMath math1 = new MyMath(1, "MathObj1");
          // math1.id = 2; // ERROR: Cannot assign a value to final variable id
  
          math1.printID();    // Calls final method
          math1.printName();  // Calls instance method
  
          MyMath math2 = new MyMath(2, "MathObj2");
          System.out.println("Instance count after 2 objects (static method): " + MyMath.getInstanceCount()); // 2
  
          AdvancedMath advMath = new AdvancedMath(3, "AdvMathObj1");
          advMath.printID();   // Calls inherited final method
          advMath.printName(); // Calls overridden method in AdvancedMath
  
          ImmutablePoint p = new ImmutablePoint(10, 20);
          // p = new ImmutablePoint(30, 40); // This would be allowed if 'p' itself was not final.
                                          // Here, the object p refers to is immutable.
  
          final ImmutablePoint finalP = new ImmutablePoint(5,5);
          // finalP = new ImmutablePoint(1,1); // ERROR: finalP is a final reference.
          // The object finalP points to is also immutable due to its class design.
      }
  }
  

  ---

  10. == vs equals() method

  These are used for comparison in Java, but they compare different things.

  == operator

  • Primitives: For primitive types (int, char, boolean, etc.), == compares their actual values.
    • int a = 5; int b = 5; then a == b is true.

  • Objects:== vs equals() method

    For
    object
    • reference types (String, ArrayList, custom objects, etc.), == comparesoperator: their
      • For primitive types: Compares values.
      • For objects: Compares memory addresses (references). It checksChecks if two reference variablesreferences point to the exact same object in memory.
        • String s1 = new String("hello"); String s2 = new String("hello"); then s1 == s2 is false because s1 and s2 refer to two different objects in memory, even though their content is the same.
        • String s3 = "hello"; String s4 = "hello"; then s3 == s4 is true due to String interning (string pool optimization for literals).
        • MyObject o1 = new MyObject(); MyObject o2 = o1; then o1 == o2 is true because o2 is assigned the same reference as o1.

      equals() method

      • Definition: A method defined in the java.lang.Object class. Its default implementation in Object class behaves exactly like == for objects (i.e., it compares references).
        • public boolean equals(Object obj) object.
      • Overriding: Classes like String, Integer, Date, and collection classes override the equals() method to provide "logical" or "content" equality. They compare the actual content or state of the objects, not just their memory addresses.method:
        • For String, equals() compares the sequence of characters.
        • For Integer, equals() compares the wrapped integer value.
      • Custom Classes: If you don't override equals()Defined in your custom class, it will inherit the Object class's implementation, which means it will perform a reference comparisonclass (default implementation is ==).
      It's
      • Often a common practice to override equals() (and hashCode())overridden in custom classes if you need to define logical equality based on the object's attributes.
      • Contract: When overriding equals(), you must also override hashCode() to maintain the general contract: if a.equals(b) is true, then a.hashCode() == b.hashCode() must be true.

      Key Differences

      Feature	== Operator	equals() Method
      Type	Operator	Method
      Primitives	Compares values	Not applicable (cannot call methods on primitives)
      Objects (Default)	Compares references (memory addresses)	Compares references (default Object.equals() behavior)
      Objects (Overridden)	Still compares references	Compares content/state (if overridden appropriately, e.g., in String, Integer)
      Usage	Value comparison for primitives, reference comparison for objects.	Content/logical comparison for objects (when properly overridden).

      Example

      class Point {
          private int x;
          private int y;
      
          public Point(int x, int y) {
              this.x = x;
              this.y = y;
          }
      
          // getters...
      
          // Without overriding equals() and hashCode(), Point instances
          // will be compared by reference using the default Object.equals().
      
          @Override
          public boolean equals(Object o) {
              if (this == o) return true; // Same object reference
              if (o == null || getClass() != o.getClass()) return false; // Null or different class
              Point point = (Point) o;
              return x == point.x && y == point.y; // Compare content
          }
      
          @Override
          public int hashCode() {
              // A simple hash code implementation
              int result = x;
              result = 31 * result + y;
              return result;
              // Or use Objects.hash(x, y) from Java 7+
          }
      }
      
      public class EqualsVsDoubleEqual {
          public static void main(String[] args) {
              // --- Primitives ---
              int a = 10;
              int b = 10;
              int c = 20;
      
              System.out.println("Primitives:");
              System.out.println("a == b: " + (a == b)); // true (10 == 10)
              System.out.println("a == c: " + (a == c)); // false (10 == 20)
              // a.equals(b); // COMPILE ERROR: equals() cannot be called on primitives
      
              // --- Objects (String - special case with string pool) ---
              String s1 = "hello"; // String literal, goes into string pool
              String s2 = "hello"; // Another literal, reuses from string pool
              String s3 = new String("hello"); // Explicitly creates a new object on the heap
              String s4 = new String("hello"); // Explicitly creates another new object on the heap
      
              System.out.println("\nStrings:");
              System.out.println("s1 == s2: " + (s1 == s2)); // true (both point to the same object in string pool)
              System.out.println("s1 == s3: " + (s1 == s3)); // false (s1 is in pool, s3 is a new heap object)
              System.out.println("s3 == s4: " + (s3 == s4)); // false (s3 and s4 are distinct heap objects)
      
              System.out.println("s1.equals(s2): " + s1.equals(s2)); // true (content is the same)
              System.out.println("s1.equals(s3): " + s1.equals(s3)); // true (content is the same)
              System.out.println("s3.equals(s4): " + s3.equals(s4)); // true (content is the same)
      
              // --- Objects (Custom Class Point) ---
              Point p1 = new Point(1, 2);
              Point p2 = new Point(1, 2);
              Point p3 = p1; // p3 now refers to the same object as p1
      
              System.out.println("\nCustom Objects (Point):");
              System.out.println("p1 == p2: " + (p1 == p2)); // false (p1 and p2 are different objects in memory)
              System.out.println("p1 == p3: " + (p1 == p3)); // true (p1 and p3 refer to the same object)
      
              // If Point did NOT override equals(), this would be false.
              // Since Point DOES override equals() to compare x and y, this is true.
              System.out.println("p1.equals(p2): " + p1.equals(p2)); // true (content is the samecontent dueor tological overridden equals)
              System.out.println("p1.equals(p3): " + p1.equals(p3)); // true (same object, content also same)
      
              Object o = new Object();
              Object o2 = new Object();
              System.out.println("o.equals(o2) without override: " + o.equals(o2)); // false, default is ==
          }
      }
      

      ---

      (The remaining answers will follow this detailed format. This is a lotequality of information,objects, sonot I'lljust continuetheir inreferences.

    subsequent
    responses
  if
  needed
to
• avoid making one response excessively long.) Okay, continuing with the detailed explanations:

  ---

  11.

  Autoboxing vs Unboxing

  These are convenience features introduced in Java 5 that allow automatic conversion between primitive types and their corresponding wrapper classes.

  Autoboxing

  • Definition:Autoboxing: The automaticAutomatic conversion thatby the Java compiler makes betweenof a primitive type andto its corresponding wrapper class object wrapper class. For example, converting an(e.g., int to an Integer, a double to a Double, etc.).
  • When it happens:Unboxing:
    Automatic
    • Whenconversion by the Java compiler of a primitivewrapper valueclass isobject passed as a parameterback to a method that expects an object of theits corresponding wrapper class.
    • When a primitive value is assigned to a variable of the corresponding wrapper class.
    • When a primitive is added to a collection that expects objectstype (e.g., ArrayList<Integer> to int).

  Unboxing

  • Definition: The automatic conversion that the Java compiler makes from a wrapper class object to its corresponding primitive type. For example, converting an Integer to an int, a Double to a double, etc.

  • When it happens:
    • When an object of a wrapper class is passed as a parameter to a method that expects a value of the corresponding primitive type.
    • When an object of a wrapper class is assigned to a variable of the corresponding primitive type.
    • In arithmetic operations involving wrapper objects (the object is unboxed to a primitive before the operation).
  • Caution: Unboxing a null wrapper object will result in a NullPointerException.

  Key Differences

  Feature	Autoboxing	Unboxing
  Conversion	Primitive type → Wrapper class object	Wrapper class object → Primitive type
  Example	int i = 10; Integer obj = i;	Integer obj = new Integer(10); int i = obj;
  Potential Issue	Less direct, slight performance overhead.	NullPointerException if wrapper object is null.

  Example

  import java.util.ArrayList;
  import java.util.List;
  
  public class AutoboxingUnboxingExample {
      public static void main(String[] args) {
          // --- Autoboxing ---
          // Primitive int to Integer object
          int primitiveInt = 10;
          Integer wrapperInt = primitiveInt; // Autoboxing: int -> Integer
          // Under the hood, this is like: Integer wrapperInt = Integer.valueOf(primitiveInt);
  
          System.out.println("Primitive int: " + primitiveInt);
          System.out.println("Autoboxed Integer: " + wrapperInt);
  
          List<Integer> integerList = new ArrayList<>();
          integerList.add(20); // Autoboxing: int 20 -> Integer.valueOf(20)
          integerList.add(primitiveInt); // Autoboxing
  
          System.out.println("List of Integers: " + integerList);
  
          takesIntegerObject(30); // Autoboxing: int 30 -> Integer.valueOf(30)
  
          // --- Unboxing ---
          Integer anotherWrapperInt = Integer.valueOf(50);
          int anotherPrimitiveInt = anotherWrapperInt; // Unboxing: Integer -> int
          // Under the hood, this is like: int anotherPrimitiveInt = anotherWrapperInt.intValue();
  
          System.out.println("\nUnboxed primitive int: " + anotherPrimitiveInt);
  
          int sum = anotherWrapperInt + 5; // Unboxing: anotherWrapperInt is unboxed to int before addition
          System.out.println("Sum (unboxing in expression): " + sum);
  
          int valFromList = integerList.get(0); // Unboxing: Element from list (Integer) to int
          System.out.println("Value from list (unboxed): " + valFromList);
  
          takesPrimitiveInt(anotherWrapperInt); // Unboxing: Integer -> int
  
          // --- Potential NullPointerException with Unboxing ---
          Integer nullInteger = null;
          try {
              // int problematicInt = nullInteger; // This would cause NullPointerException
              if (nullInteger != null && nullInteger > 0) { // Guarded unboxing
                   System.out.println("This won't print");
              }
              // Or more directly, to show the error:
               int npeInt = nullInteger.intValue(); // This is what unboxing effectively does
          } catch (NullPointerException e) {
              System.out.println("\nCaught NullPointerException during unboxing: " + e.getMessage());
          }
      }
  
      public static void takesIntegerObject(Integer num) {
          System.out.println("Method takesIntegerObject received: " + num);
      }
  
      public static void takesPrimitiveInt(int num) {
          System.out.println("Method takesPrimitiveInt received: " + num);
      }
  }
  

  ---

  12. Checked exceptions vs Unchecked exceptions

  Java's exception handling mechanism categorizes exceptions into these two main types, which differ in how the compiler enforces their handling. Both are subclasses of java.lang.Throwable. Error is another subclass of Throwable for severe system issues, usually not handled by applications.

  Checked Exceptions

  • Definition:Checked exceptions: Exceptions that the Java compiler checks at compile-time. They represent exceptional conditions that a well-written application should anticipate and recover from.
  • Subclasses of: java.lang.Exception (but not java.lang.RuntimeException or its subclasses).
  • Handling:
    • A method that might throw a checked exception must either:
      1. Handle it using a try-catch block.
      2. Declare it in its throws clause, propagating the responsibility to the caller.
  • Examples: IOException, SQLException, FileNotFoundException, ClassNotFoundException.
  • Purpose: To force programmers to deal with predictable, though exceptional, situations.

  Unchecked Exceptions (Runtime Exceptions)

  • Definition: Exceptions that the Java compiler does not check at compile-time. They usually indicate programming errors or unexpected conditions that are often unrecoverable or should have been prevented by better coding.
  • Subclasses of: java.lang.RuntimeException (which itself is a subclass of java.lang.Exception). Error and its subclasses are also unchecked, but typically not caught.
  • Handling:
    • The compiler does not require you to handle or declare them.
    • You can still use try-catch blocks for them, but it's often a sign of fixing a symptom rather than the root cause (e.g., catching NullPointerException instead of ensuring an object is not null).
  • Examples: NullPointerException, ArrayIndexOutOfBoundsException, IllegalArgumentException, ArithmeticException, ClassCastException.
  • Purpose: To indicate bugs in the program logic or runtime issues that are generally not anticipated for recovery by the immediate calling code.

  Key Differences

  enforcesthis.Represent

  Feature	Checked Exceptions	Unchecked Exceptions (Runtime Exceptions)
  Compiler Check	Checked at compile-time.	Not checked at compile-time.
  Handling	Must be handled (try-catch) or declared (throws).	Handling/declaring is optional.
  Parent Class	Subclass of Exception (excluding RuntimeException).	SubclassMust be declared in the throws clause of a method or handled in a RuntimeException. (Errortry-catch isblock. alsoCompiler unchecked).
  Nature	External conditions, oftenanticipated, recoverable problems (e.g., file not found, network error).	Programming errors, internal logic flaws (e.g., null pointer, bad index).
  Examples	IOException, SQLException). Unchecked exceptions: Subclasses of RuntimeException or Error. Do not need to be declared or caught (though they can be). Usually indicate programming errors (e.g., FileNotFoundException	NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException

  Example

  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException; // Checked exception
  import java.io.FileNotFoundException; // Checked exception, subclass of IOException
  
  public class CheckedUncheckedExceptions {
  
      // Method that might throw a checked exception (IOException)
      // It must declare it in the 'throws' clause) or handleunrecoverable it.system public static void readFile(String fileName) throws FileNotFoundException, IOException {
          File file = new File(fileName);
          FileReader fr = new FileReader(file); // Might throw FileNotFoundException
          // ... read file ...issues (furtherOutOfMemoryError).

operations
might throw
• IOException) System.out.println("Successfully opened (but not read): " + fileName); fr.close(); // Might throw IOException } // Method that might cause an unchecked exception public static void processNumber(String numberStr, int divisor) { if (numberStr == null) { // This would lead to NullPointerException if not checked System.out.println("Input string is null, cannot parse."); return; } try { int number = Integer.parseInt(numberStr); // Might throw NumberFormatException (unchecked) int result = number / divisor; // Might throw ArithmeticException (unchecked if divisor is 0) System.out.println("Result: " + result); } catch (NumberFormatException e) { System.err.println("Unchecked Exception: Invalid number format - " + e.getMessage()); } catch (ArithmeticException e) { System.err.println("Unchecked Exception: Cannot divide by zero - " + e.getMessage()); } // No need to declare NumberFormatException or ArithmeticException in throws clause. } public static void main(String[] args) { // --- Handling Checked Exception --- System.out.println("--- Checked Exception Example ---"); try { readFile("existing_file.txt"); // Assume this file does not exist for demo // To make it work, create an empty "existing_file.txt" // readFile("non_existent_file.txt"); } catch (FileNotFoundException e) { System.err.println("Checked Exception Caught: File not found - " + e.getMessage()); } catch (IOException e) { System.err.println("Checked Exception Caught: IO Error - " + e.getMessage()); } finally { System.out.println("File reading attempt finished."); } // --- Triggering Unchecked Exceptions --- System.out.println("\n--- Unchecked Exception Example ---"); processNumber("100", 5); // Valid processNumber("abc", 5); // NumberFormatException processNumber("100", 0); // ArithmeticException processNumber(null, 5); // Handled null case inside processNumber // Example of an unhandled unchecked exception (if not caught inside method) // String text = null; // System.out.println(text.length()); // This would throw NullPointerException } } // To run the "readFile" part without error, create an empty file named "existing_file.txt" in the same directory.

  ---

  13.

  Thread vs Runnable

  Both are used for creating and managing threads in Java for concurrent execution.

  Thread class (java.lang.Thread)

  • Definition:Thread (Class): AAn classinstance thatof representsThread is a thread of execution.
  • You Usage:extend
    1. Extendthe Thread: Create a subclass of Threadclass and override its run() methodmethod. Limits a class to definesingle theinheritance.
    task
    2. theRunnable thread(Interface): will execute. Then create anAn instance of thisa subclassclass and call its start() method.
    3. Passimplementing Runnable tohas Threada constructor:task (Morethat commoncan andbe flexible) Create an instance of Threadexecuted by passing a Runnablethread. objectYou to its constructor.
  • State: A Thread object encapsulates the thread's state, priority, name, etc.
  • Limitation: If you extend Thread, your class cannot extend any other class (Java doesn't support multiple class inheritance).

  Runnable interface (java.lang.Runnable)

  • Definition: A functional interface with a single abstract method: void run().
  • Usage:
    1. Implementimplement the Runnable interface in a class and provide the implementation for the(its run() method.
    method)
    2. Createand pass an instance of this class (the Runnable object).
    3. Createto a Thread object,constructor. passingMore theflexible Runnableas objectit toallows itsmultiple constructor:inheritance Threadof t = new Thread(myRunnable);.
    4. Call t.start() to begin execution.
  • Flexibility: Since it's an interface, your class can implement Runnableinterfaces and still extend another class. This promotes better separation of concerns:separates the task (Runnable) is separate from the execution mechanismmechanism. (Thread).Generally preferred.
• Reusability: The same Runnable instance can potentially be executed by multiple threads if its run() method is thread-safe or designed for it (though typically one Runnable is passed to one Thread for a specific task).

Key Differences

Example

// Approach 1: Extending Thread
class MyThread extends Thread {
    private String threadName;

    public MyThread(String name) {
        super(name); // Set thread name via superclass constructor
        this.threadName = name;
        System.out.println("Creating " +  threadName );
    }

    @Override
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", Count: " + i);
                Thread.sleep(50); // Simulate work
            }
        } catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
}

// Approach 2: Implementing Runnable
class MyRunnable implements Runnable {
    private String taskName;
    private Thread thread; // Optional: to hold the thread that runs this runnable

    public MyRunnable(String name) {
        this.taskName = name;
        System.out.println("Creating task " +  taskName );
    }

    @Override
    public void run() {
        System.out.println("Running task " +  taskName + " on thread " + Thread.currentThread().getName());
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Task: " + taskName + ", Count: " + i + " (Thread: " + Thread.currentThread().getName() + ")");
                Thread.sleep(70); // Simulate work
            }
        } catch (InterruptedException e) {
            System.out.println("Task " +  taskName + " interrupted.");
        }
        System.out.println("Task " +  taskName + " exiting.");
    }

    public void start() { // Convenience method to create and start the thread
        System.out.println("Starting task " + taskName);
        if (thread == null) {
            thread = new Thread(this, taskName + "-Thread"); // Pass runnable and a name for the thread
            thread.start();
        }
    }
}

public class ThreadVsRunnableExample {
    public static void main(String[] args) {
        System.out.println("--- Extending Thread ---");
        MyThread thread1 = new MyThread("Thread-A (extends Thread)");
        MyThread thread2 = new MyThread("Thread-B (extends Thread)");

        thread1.start(); // Calls run() method of MyThread
        thread2.start(); // Calls run() method of MyThread

        // Wait for threads to finish before proceeding (optional, for cleaner output)
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted.");
        }
        System.out.println("--- Finished Extending Thread Example ---");


        System.out.println("\n--- Implementing Runnable ---");
        MyRunnable runnableTask1 = new MyRunnable("Task-X (implements Runnable)");
        MyRunnable runnableTask2 = new MyRunnable("Task-Y (implements Runnable)");

        // Manually creating Thread objects for Runnable tasks
        Thread t3 = new Thread(runnableTask1, "Thread-C (for Task-X)");
        Thread t4 = new Thread(runnableTask2, "Thread-D (for Task-Y)");

        t3.start(); // Calls run() method of MyRunnable (runnableTask1)
        t4.start(); // Calls run() method of MyRunnable (runnableTask2)

        // Or using the convenience start method in MyRunnable
        // MyRunnable runnableTask3 = new MyRunnable("Task-Z (implements Runnable)");
        // runnableTask3.start();

        try {
            t3.join();
            t4.join();
            // if (runnableTask3.thread != null) runnableTask3.thread.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted.");
        }
        System.out.println("--- Finished Implementing Runnable Example ---");

        // Using Runnable with Lambda (Java 8+)
        System.out.println("\n--- Runnable with Lambda ---");
        Runnable lambdaTask = () -> {
            System.out.println("Running lambda task on thread " + Thread.currentThread().getName());
            try {
                for(int i = 2; i > 0; i--) {
                    System.out.println("Lambda Task, Count: " + i + " (Thread: " + Thread.currentThread().getName() + ")");
                    Thread.sleep(60);
                }
            } catch (InterruptedException e) {
                System.out.println("Lambda task interrupted.");
            }
            System.out.println("Lambda task exiting.");
        };

        Thread t5 = new Thread(lambdaTask, "Thread-E (for Lambda)");
        t5.start();
        try {
            t5.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted.");
        }
        System.out.println("--- Finished Runnable with Lambda Example ---");
    }
}

Why Runnable is generally preferred:

1. Decoupling: It separates the task (what to do) from the worker (the thread that does it).
2. Flexibility: Your task class can still extend another class if needed, as Java does not support multiple inheritance of classes.
3. Reusability: A Runnable can be submitted to an ExecutorService or other concurrency utilities more easily.

14. StringBuilder vs StringBuffer

Both StringBuilder and StringBuffer are mutable sequence of characters, used when you need to perform many modifications to strings (concatenation, insertion, deletion). The String class in Java is immutable.

String (briefly, for context)

• Immutable. Every modification creates a new String object.
• Inefficient for frequent modifications (e.g., building a string in a loop).

StringBuffer

• Definition:StringBuilder: A mutableMutable sequence of characters.
• Thread-Safety: Synchronized. Its methods (like append(), insert(), delete()) are synchronized, making it thread-safe. This means only one thread can access a StringBuffer object's methods at a time.
• Performance: Due to synchronization, it's slower than StringBuilder in a single-threaded environment.
• Introduced: Java 1.0.

StringBuilder

• Definition: A mutable sequence of characters.
• Thread-Safety: Not synchronized. Its methods are not synchronized, making it non-thread-safe.
• Performance: Faster than StringBuffer in a single-threaded environment because it doesn't have the overhead of synchronization.
• Introduced: Java 5, as a non-synchronized alternative to StringBuffer.

Key Differences

When to use which?

• StringBuilder:overhead. Use in most cases, especially in single-threaded applications or when the StringBuilder instance is confined to a single thread (e.g., local variable within a method). This is the common recommendation.
• StringBuffer: Use only if you need a mutable string that will be accessed and modified by multiple threads concurrently,might andmodify youthe needstring.
built-in

Example

public class StringBuilderStringBufferExample {

    public static final int ITERATIONS = 100000;

    public static void main(String[] args) {
        // --- String Concatenation (for comparison, less efficient in loops) ---
        long startTime = System.nanoTime();
        String str = "";
        for (int i = 0; i < ITERATIONS / 10; i++) { // Reduced iterations for String due to slowness
            str += "a"; // Creates new String object in each iteration
        }
        long endTime = System.nanoTime();
        System.out.println("String concatenation time: " + (endTime - startTime) / 1_000_000.0 + " ms (for " + ITERATIONS/10 + " iterations)");

        // --- StringBuffer ---
        startTime = System.nanoTime();
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < ITERATIONS; i++) {
            sBuffer.append("a");
        }
        endTime = System.nanoTime();
        System.out.println("StringBuffer append time:  " + (endTime - startTime) / 1_000_000.0 + " ms");

        // --- StringBuilder ---
        startTime = System.nanoTime();
        StringBuilder sBuilder = new StringBuilder();
        for (int i = 0; i < ITERATIONS; i++) {
            sBuilder.append("a");
        }
        endTime = System.nanoTime();
        System.out.println("StringBuilder append time: " + (endTime - startTime) / 1_000_000.0 + " ms");

        // --- Functionality (same for both StringBuilder and StringBuffer) ---
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World");    // "Hello World"
        sb.insert(5, ", Java"); // "Hello, Java World"
        sb.delete(5, 11);       // "Hello World" (deletes ", Java")
        sb.reverse();           // "dlroW olleH"
        String finalString = sb.toString();
        System.out.println("\nFinal string from StringBuilder: " + finalString);

        // --- Thread Safety Demo (Conceptual) ---
        // To truly demonstrate thread-safety issues with StringBuilder vs StringBuffer,
        // you'd need multiple threads modifying the same instance.

        // StringBuffer (thread-safe)
        StringBuffer sharedBuffer = new StringBuffer();
        Runnable taskBuffer = () -> {
            for (int i = 0; i < 1000; i++) {
                sharedBuffer.append("X");
            }
        };

        // StringBuilder (not thread-safe)
        StringBuilder sharedBuilder = new StringBuilder();
        Runnable taskBuilder = () -> {
            for (int i = 0; i < 1000; i++) {
                sharedBuilder.append("Y"); // Potential race condition
            }
        };

        Thread t1 = new Thread(taskBuffer);
        Thread t2 = new Thread(taskBuffer);
        Thread t3 = new Thread(taskBuilder);
        Thread t4 = new Thread(taskBuilder);

        t1.start(); t2.start();
        t3.start(); t4.start();

        try {
            t1.join(); t2.join();
            t3.join(); t4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("\nShared StringBuffer length (expected 2000): " + sharedBuffer.length());
        // For StringBuilder, the length might not be 2000 due to race conditions.
        // This simple append might not always show it, more complex operations would.
        System.out.println("Shared StringBuilder length (potentially < 2000): " + sharedBuilder.length());
        // To make StringBuilder safe in a multi-threaded context, you would do:
        // synchronized(sharedBuilder) { sharedBuilder.append("Y"); }
    }
}

Output for the performance part will show StringBuilder is generally faster than StringBuffer, and both are much faster than repeated String concatenation in a loop. The thread-safety demo for length might consistently show 2000 for StringBuilder in simple appends because append(char) operations might be atomic enough on some JVMs/OSs for this trivial case. A more complex sequence of operations or more contention would more reliably show data corruption or incorrect lengths with StringBuilder in a concurrent setting without external synchronization.

15. Synchronized methods vs Synchronized blocks

Both are mechanisms in Java to control access to shared resources by multiple threads, preventing race conditions and ensuring data consistency. They work by acquiring an intrinsic lock (also called a monitor lock) associated with an object.

Synchronized Methods

• Definition:Synchronized methods: ALock the entire method declared withusing the synchronizedobject's keyword.
• Locking:
  • Instance Method: When a synchronized instance method is called, the thread acquires the intrinsic lock for that specific instancemonitor (the this object) of the class. No other thread can execute any other synchronizedfor instance method on the same object until the lock is released.
  • Static Method: When a synchronized static method is called, the thread acquires the intrinsic lock formethods, the Class object associatedfor withstatic thatmethods). class.Simpler Noto otherimplement threadbut can execute any other synchronized static method in the same class until the lock is released.
• Scope: The entire method is synchronized. The lock is acquired when the method is entered and released when the method exits (either normally or duelead to anlower unhandledconcurrency exception).
• Granularity: Coarser-grained locking. Ifif only a small part of the method needs synchronization, the entire method still gets locked, potentially reducing concurrency.

Synchronized Blocks

• Definition: A block of code marked with the synchronized keyword, followed by an object reference in parentheses. synchronized (objectReference) { // code to be synchronized } protection.
• Locking:Synchronized blocks: TheAllow threadfiner-grained acquires the intrinsic lock for the object specified in objectReference. No other thread can execute another synchronized block on the same objectReference until the lock is released.
• Object for Locking:
  • this: Lockslocking on the current instance (similar to a synchronized instance method, but for a specific block).
  object's
  • monitor MyClass.class:for Locks on the Class object (similar toonly a synchronized static method, but for a specific block).
  • Any other object: Can use a dedicated lock object (e.g., private final Object lock = new Object();). This is often preferred for finer-grained control and to avoid unintended lock contention.
• Scope: Only the code within the block is synchronized.
• Granularity: Finer-grained locking. Allows you to synchronize only the critical sections of code that access shared resources, leaving other parts of the method non-synchronized, potentially improving concurrency.

Key Differences

Serialization

Whenvs to use which?

• Synchronized Method:Serialization: UseThe whenprocess of converting an object's state (its field values) into a byte stream, which can then be stored in a file, sent over a network, or stored in a database. The class must implement the entirejava.io.Serializable logicmarker of a method needs to be executed atomically with respect to other synchronized methods on the same object (or class for static methods). It's simpler to write.interface.
• Synchronized Block:Deserialization:
  The
  • Usereverse when only a partprocess of a method needs synchronization.
  • Use when you need to synchronize onreconstructing an object otherfrom thanits serialized byte stream representation.

• HashMap vs TreeMap

  • HashMap: Implements thisMap. Uses a hash table. Does not guarantee any order of iteration. Allows one null orkey and multiple ClassName.classnull values. Offers average O(1) time complexity for get and put.
  • Use whenTreeMap: differentImplements criticalSortedMap. sectionsUses withina red-black tree. Stores entries sorted by their keys (natural order or by a provided Comparator). Does not allow null keys (if using natural ordering). Offers O(log n) time complexity for get and put.

• ArrayList vs LinkedList

  • ArrayList: Implements List using a dynamically resizable array. Fast random access (get(index) is O(1)). Slower for additions/removals in the samemiddle class(O(n)) because elements need to be protectedshifted.
  by
  • differentLinkedList: locksImplements List using a doubly-linked list. Slower random access (get(index) is O(n)). Faster for additions/removals at the beginning, end, or middle (if an iterator is positioned, O(1)) as only pointers need to be updated. Higher memory overhead per element.

• HashMap vs Hashtable

  • HashMap: Not synchronized (not thread-safe). Allows one null key and multiple null values. Faster. Part of the Java Collections Framework. Preferred for non-concurrent use.
  • Hashtable: Synchronized (thread-safe). Does not allow morenull concurrencykeys or null values (throws NullPointerException). Slower due to synchronization. A legacy class; ConcurrentHashMap is generally preferred for thread-safe map operations.

• Enum vs Constant variables

  • Constant variables (e.g., onepublic blockstatic locksfinal onint RED = 1;): Provide fixed values but lack type safety (e.g., you could pass any lock1int, anotherwhere ona lock2)color constant is expected). No intrinsic grouping or behavior.
  • Often preferredEnum (Enumeration): A special data type that enables for bettera performancevariable to be a set of predefined constants. Type-safe (compiler checks values). Can have constructors, methods, and finerimplement control,interfaces. especiallyProvides inbetter complexreadability concurrentand applications.maintainability.
  Using
  private
dedicated
• lock

  Singleton pattern vs Prototype pattern

  • Singleton pattern (Creational): Ensures a class has only one instance and provides a global point of access to it. Useful for managing shared resources like database connections or logging.
  • Prototype pattern (Creational): Creates new objects by copying an existing object (privatethe finalprototype). ObjectUseful lockwhen =object new Object();)creation is a good practice to avoid exposing locksexpensive and potentialyou deadlocksneed ifmany external code tries to lock on your publicsimilar objects.

classCollection Countervs {Manual privatememory intmanagement

count

=

0;Garbage privateCollection int(GC): anotherCountAutomatic =process 0;(e.g., //in LockJava, objectC#) where the runtime environment reclaims memory occupied by objects that are no longer referenced by the program. Reduces risks of memory leaks and dangling pointers.


Manual memory management: Programmer is responsible for finer-grainedexplicitly synchronization
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    // Synchronized instance methodallocating (locksmalloc, on 'this' object)
    public synchronized void incrementMethodSync(new) {and //deallocating Entire(free, methoddelete) memory (e.g., in C, C++). Offers more control but is synchronizederror-prone.
System.out.println(Thread.currentThread(

30. @SpringBootApplication vs @Configuration

    • @SpringBootApplication: A convenience annotation that combines @Configuration, @EnableAutoConfiguration, and @ComponentScan with their default attributes. Typically used on the main application class.
    • @Configuration: A class-level annotation indicating that the class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime.

31. @ComponentScan vs @EnableAutoConfiguration

    • @ComponentScan: Tells Spring where to look for Spring-managed components (beans marked with @Component, @Service, @Repository, @Controller, etc.);. ThreadBy t2default (when used with @SpringBootApplication), it scans the package of the main application class and its sub-packages.
    • @EnableAutoConfiguration: Enables Spring Boot's auto-configuration mechanism, which attempts to automatically configure your Spring application based on the JAR dependencies you have added to the classpath.

32. @Configuration vs @Bean

    • @Configuration: Class-level annotation. Declares that a class can contain bean definition methods. Spring processes such classes to create and manage beans.
    • @Bean: Method-level annotation. Used within a @Configuration class. Indicates that the method produces a bean to be managed by the Spring container. The returned object from the method is registered as a bean.

33. @Autowired vs @Qualifier

    • @Autowired: Marks a constructor, field, setter method, or config method to be autowired by Spring's dependency injection facilities. Spring attempts to resolve the dependency by type. If multiple beans of the same type exist, it can lead to ambiguity.
    • @Qualifier("beanName"): Used in conjunction with @Autowired to specify which exact bean to inject when there are multiple beans of the same type. It resolves ambiguity by name.

34. @RestController vs @Controller

    • @Controller: A specialization of @Component. Marks a class as a Spring MVC controller. Handler methods typically return a view name (e.g., for Thymeleaf, JSP rendering) or redirect.
    • @RestController: A convenience annotation that combines @Controller and @ResponseBody. Marks a class as a controller where every handler method automatically serializes the return object into the HTTP response body (e.g., as JSON or XML). Primarily used for building RESTful APIs.

35. @RequestMapping vs @GetMapping

    • @RequestMapping: A general-purpose annotation for mapping HTTP requests to handler methods. Can specify HTTP methods (GET, POST, etc.), path, headers, params. Can be used at class or method level.
    • @GetMapping: A shortcut annotation specifically for mapping HTTP GET requests. Equivalent to @RequestMapping(method = RequestMethod.GET). More concise for GET mappings.

36. @PathVariable vs @RequestParam

    • @PathVariable: Binds a method parameter to a URI template variable. Used to extract values from the path of the URL (e.g., /users/{id}).
    • @RequestParam: Binds a method parameter to a web request parameter. Used to extract values from the query string of a URL (e.g., /search?query=java) or from submitted form data.

37. @PostMapping vs @PutMapping

    • @PostMapping: A shortcut annotation specifically for mapping HTTP POST requests. Equivalent to @RequestMapping(method = RequestMethod.POST). Typically used for creating new Thread(resources.
    • @PutMapping: A shortcut annotation specifically for mapping HTTP PUT requests. Equivalent to @RequestMapping(method = RequestMethod.PUT). Typically used for updating an existing resource completely (or creating it if it doesn't exist, making it idempotent).

38. PUT vs PATCH (HTTP Methods)

    • PUT: An HTTP method used to replace an entire resource at a specific URI with the request payload. If the resource doesn't exist, PUT might create it. Idempotent (multiple identical requests have the same effect as a single one).
    • PATCH: An HTTP method used to apply partial updates to a resource. Modifies only the specified fields in the request payload, leaving other fields unchanged. Not necessarily idempotent.

39. @ExceptionHandler vs @ControllerAdvice

    • @ExceptionHandler: A method-level annotation within a controller (or @ControllerAdvice class). Defines a method that handles specific types of exceptions thrown by request handler methods within that controller (or globally if in @ControllerAdvice).
    • @ControllerAdvice: A class-level annotation that allows you to consolidate common controller-related concerns (like exception handling, model attributes, init binders) into a single, global component. Often used with @ExceptionHandler methods for centralized error handling across multiple controllers.

40. @Primary vs @Qualifier

    • @Primary: When multiple beans of the same type are eligible for autowiring, the bean marked with @Primary is given preference and will be chosen by default if no other more specific criteria (like @Qualifier) ->are {used.
    for(int
    • i=0;@Qualifier("beanName"): i<3;Used i++)to c1.incrementMethodSync();explicitly },specify "T2-MethodSync-c1");which //named Thisbean threadto operatesinject when multiple beans of the same type exist. It overrides @Primary if both are present and a qualifier is used at the injection point.

41. @Async vs @Scheduled

    • @Async: Marks a method to be executed asynchronously in a separate thread, managed by Spring. The caller does not wait for the method to complete. Requires @EnableAsync on a differentconfiguration objectclass.
    c2,
    • so@Scheduled: itMarks won'ta contendmethod withto t1,be t2executed forat c1'sscheduled lockintervals Threador t_c2fixed =times new Thread(() -> { for(int i=0; i<3; i++) c2.incrementMethodSync(); }e.g., "T_MethodSync-c2");using //cron Testexpressions, synchronizedfixed blockrate, or fixed delay). Requires @EnableScheduling on 'this'a Threadconfiguration t3class.
    =
    new
Thread(()
42. -> { for(int i=0; i<3; i++) c1.incrementBlockThisSync(); }, "T3-BlockThisSync-c1"); // Test synchronized block on dedicated lock // These two threads can run concurrently if they use different lock objects (lock1

    @Cacheable vs lock2)@CacheEvict

    //
    or
    • if@Cacheable: theyMarks operatea onmethod differentwhose Counterresult instances.should //be cached. If incrementBlockDedicatedLockthe andmethod anotherOperationWithDifferentLock areis called onagain SAME c1 instance, // they can run concurrently because they use different locks (lock1, lock2). Thread t4 = new Thread(() -> { for(int i=0; i<3; i++) c1.incrementBlockDedicatedLock(); }, "T4-BlockLock1-c1"); Thread t5 = new Thread(() -> { for(int i=0; i<3; i++) c1.anotherOperationWithDifferentLock(); }, "T5-BlockLock2-c1"); // Test static synchronized method // Threads will contend for Counter.class lock Thread t6 = new Thread(() -> { for(int i=0; i<3; i++) Counter.incrementStaticMethodSync(); }, "T6-StaticSync"); Thread t7 = new Thread(() -> { for(int i=0; i<3; i++) Counter.incrementStaticMethodSync(); }, "T7-StaticSync"); System.out.println("--- Starting Method Sync Demo (on c1) ---"); t1.start(); t2.start(); t_c2.start(); t1.join(); t2.join(); t_c2.join(); System.out.println("c1.count after method sync: " + c1.getCount()); // Expected: 6 System.out.println("c2.count after method sync: " + c2.getCount()); // Expected: 3 c1.count = 0; // Reset for next test System.out.println("\n--- Starting Block 'this' Sync Demo (on c1) ---"); t3.start(); // Let's start another one to see contention Thread t3_contend = new Thread(() -> { for(int i=0; i<3; i++) c1.incrementBlockThisSync(); }, "T3_Contend-BlockThisSync-c1"); t3_contend.start(); t3.join(); t3_contend.join(); System.out.println("c1.count after block 'this' sync: " + c1.getCount()); // Expected: 6 System.out.println("\n--- Starting Block Dedicated Lock Demo (on c1, different locks) ---"); // t4 and t5 use different locks onwith the same objectarguments, c1,the socached theyresult is returned directly without executing the method body. Requires @EnableCaching and a cache manager.
    • @CacheEvict: Marks a method that should trigger cache eviction (removal of one or more entries from the cache). Typically used when data that might be cached is modified (e.g., after an update or delete operation).

43. application.properties vs application.yml

    • Both are files used in Spring Boot to externalize application configuration.
    • application.properties: Uses standard Java properties file format (key=value pairs). Simple, flat structure.
    • application.yml (or .yaml): Uses YAML (YAML Ain't Markup Language) format. More hierarchical and often considered more readable for complex configurations. Supports lists, maps, and more structured data representation. Spring Boot gives YAML precedence if both files exist for the same property.

44. Microservices architecture vs Monolithic architecture

    • Monolithic architecture: The entire application is built as a single, large, undecomposable unit. All modules are tightly coupled and deployed together. Simpler to develop and deploy initially, but can runbecome hard to scale, maintain, and update.
    • Microservices architecture: The application is structured as a collection of small, independent, loosely coupled services. Each service focuses on a specific business capability and can be developed, deployed, and scaled independently. Offers better scalability, resilience, technology diversity, and team autonomy, but introduces complexity in management, deployment, and inter-service communication.

45. JAR vs WAR files

    • JAR (Java Archive): Standard Java packaging format. Can contain compiled Java classes, resources, and a manifest file. Used for libraries, plugins, or executable Java applications (if it includes a main class and is marked as executable). Spring Boot typically produces executable JARs (fat JARs) that embed a servlet container.
    • WAR (Web Application Archive): Specifically for packaging Java web applications to be deployed on a standalone servlet container (e.g., Tomcat, Jetty, WebLogic). Contains web resources (HTML, CSS, JS), servlets, JSPs, Java classes (WEB-INF/classes), and libraries (WEB-INF/lib).

46. Maven vs Gradle

    • Both are build automation tools and dependency management tools for Java projects.
    • Maven: Uses XML for configuration (pom.xml). Emphasizes "convention over configuration." Well-established, large ecosystem. Can be verbose. Relies on a lifecycle of phases and goals.
    • Gradle: Uses a Groovy or Kotlin-based DSL (Domain Specific Language) for build scripts (build.gradle). More flexible and expressive. Often offers better performance due to incremental builds and build caching. Can have a steeper learning curve for complex customizations.

47. Continuous Integration vs Continuous Deployment

    • Continuous Integration (CI): A development practice where developers frequently merge their code changes into a central repository, after which automated builds and tests are run. Aims to detect integration issues early and often.
    • Continuous Deployment (CD): Extends CI. Every code change that passes all stages of the CI pipeline (build, automated tests) is automatically deployed to a production environment. Aims for rapid and reliable releases. (Often, "Continuous Delivery" is a prerequisite, meaning every change is releasable, but the actual deployment to production might be a manual business decision).

48. Agile vs Waterfall methodologies

    • Waterfall: A traditional, sequential software development methodology. Progress flows downwards through distinct phases: requirements, design, implementation, testing, deployment, and maintenance. Less flexible to changes once a phase is complete.
    • Agile: An iterative and incremental approach to software development. Emphasizes collaboration, customer feedback, rapid delivery of working software in small increments (sprints/iterations), and adaptability to changing requirements. (Examples: Scrum, Kanban).

49. RESTful API vs SOAP API

    • RESTful API (Representational State Transfer): An architectural style for designing networked applications. Uses standard HTTP methods (GET, POST, PUT, DELETE, etc.). Typically uses JSON or XML for data format over HTTP/HTTPS. Stateless, scalable, and simpler.
    • SOAP API (Simple Object Access Protocol): A protocol for exchanging structured information. Uses XML for its message format and usually relies on other application layer protocols (most notably HTTP or SMTP) for message negotiation and transmission. More rigid, has built-in standards for security (WS-Security), transactions, etc. Can be stateful. Generally more concurrentlycomplex t4.start();and t5.start();verbose t4.join();than t5.join();REST.
    System.out.println("c1.anotherCount
    after
block
50. dedicated

    Reactive lock:programming vs Imperative programming

    • Imperative programming: A paradigm where you write code that describes how to achieve results using a sequence of statements that change the program's state. Traditional procedural and most object-oriented programming falls into this category (e.g., "do +this, c1.getAnotherCount(then do that, then update this variable"));.
    //
    • Expected:Reactive 3programming: System.out.println("\n---A Startingdeclarative Staticprogramming Methodparadigm Sync Demo ---"); t6.start(); t7.start(); t6.join(); t7.join(); System.out.println("Counter.staticCount after static sync: " + Counter.getStaticCount()); // Expected: 6 } }

      ---

      I will continueconcerned with data streams and the next setpropagation of questions.

      change. You define data flows, and the system reacts to changes in those flows automatically. Asynchronous and event-driven. Focuses on what should happen when data arrives or changes (e.g., spreadsheets, UI event handling, Spring WebFlux).