SDE Interview DS & DBMS Notes

Cheatsheet Content

1. Core Java Concepts 1.1. JVM, JRE, JDK - The Java Ecosystem JVM (Java Virtual Machine): An abstract machine that acts as the runtime engine for Java applications. It executes Java bytecode. It enables "Write Once, Run Anywhere" (WORA) by translating bytecode into platform-specific machine code. Each operating system has its specific JVM implementation. JRE (Java Runtime Environment): The minimum necessary to *run* a Java program. It bundles the JVM along with the core Java class libraries (like java.lang , java.util , etc.). It does not include development tools. JDK (Java Development Kit): For *developing* Java applications. It includes the JRE, plus development tools such as the Java compiler ( javac ), archiving tool ( jar ), and documentation generator ( javadoc ). 1.2. Object-Oriented Programming (OOP) Pillars Encapsulation: Bundling data (attributes) and methods that operate on that data within a single unit (a class). Hides the internal state of an object from the outside, providing controlled access through public methods (getters/setters). This protects data integrity and simplifies changes to internal implementation without affecting external code. Inheritance: A mechanism where a new class (subclass/child) derives properties and behaviors from an existing class (superclass/parent). It promotes code reusability and establishes an "is-a" relationship (e.g., a "Dog is an Animal"). Java supports single inheritance for classes (a class can extend only one parent). Polymorphism: Meaning "many forms," this principle allows objects to be treated as instances of their parent class rather than their actual class. Compile-time (Static) Polymorphism: Achieved primarily through Method Overloading, where multiple methods in the same class have the same name but different parameter lists (number, type, or order of arguments). The correct method is determined during compilation. Runtime (Dynamic) Polymorphism: Achieved through Method Overriding, where a subclass provides its own specific implementation of a method already defined in its superclass. The actual method called is determined at runtime based on the object's actual type, not the reference type. This relies on the concept of virtual method invocation. Abstraction: Focuses on showing only essential features of an object or system while hiding the complex implementation details. It allows you to design and use complex systems by focusing on "what" they do, rather than "how" they do it. In Java, abstraction is realized using Abstract Classes and Interfaces. 1.3. Access Modifiers - Controlling Visibility public : Members (classes, methods, fields) are accessible from anywhere, by any other class or package. This is the least restrictive access. protected : Members are accessible within the same package, and also by all subclasses (regardless of whether they are in the same package or a different package). default (no modifier): If no access modifier is specified, it defaults to package-private. Members are accessible only within the same package. They are not visible to subclasses in different packages. private : Members are accessible only within the class they are declared in. They are not visible to any other class, even subclasses or classes in the same package. This is the most restrictive access, primarily used for encapsulation. 1.4. Keywords - Special Meanings final : For a Variable: Makes the variable a constant; its value cannot be reassigned after initialization. For reference types, it means the reference cannot be changed to point to another object, but the object itself can be modified (unless the object itself is immutable). For a Method: Prevents subclasses from overriding that specific method. This can be used for security or to ensure a specific implementation is always used. For a Class: Prevents the class from being inherited. A final class cannot have any subclasses. This implies all methods in a final class are implicitly final . Common examples include String and wrapper classes. static : This keyword indicates that a member (field, method, nested class) belongs to the class itself, rather than to any specific instance of the class. Static Variable: A single copy of the variable exists for the entire class, shared by all objects of that class. Changes made by one object are visible to all others. Static Method: Can be called directly using the class name (e.g., ClassName.methodName() ) without creating an object. A static method can only access other static members (variables or methods) of its class directly; it cannot access non-static (instance) members directly because it doesn't operate on a specific object instance. It cannot use this or super . Static Block: A block of code executed only once when the class is first loaded into memory. Used for static initializations. Static Nested Class: Unlike inner classes, a static nested class does not require an instance of the outer class to be created. It behaves like a top-level class but is declared within another class. It can only directly access static members of the outer class. abstract : Abstract Method: A method declared without an implementation (no method body). It signifies that subclasses *must* provide their own implementation of this method. Abstract methods can only exist within abstract classes or interfaces. Abstract Class: A class that cannot be instantiated directly. It can contain both abstract and non-abstract (concrete) methods. Its purpose is to be extended by other classes, which then provide implementations for the abstract methods. It serves as a blueprint for its subclasses, enforcing certain behaviors. this : This keyword is a reference to the current object (the instance of the class on which the method or constructor is being invoked). It's primarily used to: Distinguish between instance variables and local variables/parameters with the same name. Call another constructor of the same class ( this(...) ). Pass the current object as an argument to another method. super : This keyword is a reference to the immediate parent class object. It's used to: Call the parent class's constructor ( super(...) ). This must be the first statement in a subclass constructor. Access a parent class's member (method or field) that has been overridden or hidden by the subclass. transient : Applied to a field, it marks that field to not be serialized when an object is written to a persistent storage (e.g., file, network stream). This is useful for sensitive data (like passwords) or data that can be recomputed. volatile : Applied to a field, it ensures that changes to that field are immediately visible to all threads. It prevents compilers and CPUs from caching the variable's value in local registers, forcing reads and writes directly to main memory. It guarantees visibility but *not* atomicity (e.g., volatile int counter; counter++; is not atomic). Use for flags or status variables. (See Java Memory Model). synchronized : Used for thread synchronization. It ensures that only one thread can execute a critical section of code (method or block) at a time. (See Concurrency). native : Used to declare that a method's implementation is provided by platform-specific code (e.g., C/C++). It's part of the Java Native Interface (JNI). strictfp : Ensures floating-point computations are performed in a strict, platform-independent manner, producing identical results across different JVM implementations. It can be applied to classes, interfaces, or methods. assert : Used for debugging. It checks a condition; if the condition is false, it throws an AssertionError . Assertions are typically disabled in production environments. 1.5. Constructors - Object Initialization A constructor is a special type of method used to initialize an object when it is created. Its name must be exactly the same as the class name, and it has no return type. Default Constructor: If you don't define any constructor in a class, the Java compiler automatically provides a public, no-argument constructor. Parameterized Constructor: A constructor that takes one or more arguments, allowing you to initialize an object with specific values at the time of creation. Constructor Overloading: A class can have multiple constructors, provided each has a different parameter list (different number, type, or order of arguments). Constructor Chaining: this(...) : Used within a constructor to call another constructor of the *same* class. It must be the first statement in the constructor. super(...) : Used within a constructor to explicitly call a constructor of the *immediate parent* class. It must be the first statement in the constructor. If not explicitly called, Java implicitly inserts a call to the parent's no-argument constructor if it exists. 1.6. Interfaces vs. Abstract Classes - Abstraction Tools Feature Interface Abstract Class Purpose Defines a contract for behavior ("what" a class can do). Provides a common base for related classes, offering partial implementation and enforcing methods ("what" a class is). Methods All public abstract by default (Java 7-). Can have default , static , and private methods with implementations (Java 8+). Can have any type of methods: abstract (no body), public , protected , private (with bodies), and static . Variables All variables are implicitly public static final by default (constants). Can have any type of variables (static, non-static, final, non-final). Constructors Cannot have constructors. Can have constructors, which are used by subclasses via super() . Inheritance A class can implement multiple interfaces (achieving multiple inheritance of type). An interface can extend multiple other interfaces. A class can only extend one abstract class (single inheritance). An abstract class can extend another class and implement interfaces. Instantiation Cannot be instantiated directly. Cannot be instantiated directly. Special Case: Default methods in interfaces (Java 8+) allow adding new methods to interfaces without breaking existing implementing classes, providing backward compatibility. Static methods in interfaces are utility methods for the interface itself. 1.7. Exception Handling - Dealing with Errors Gracefully Purpose: Provides a structured way to handle runtime errors and exceptional conditions, preventing program crashes and allowing for graceful recovery. Keywords: try , catch , finally , throw , throws . Types of Exceptions: Checked Exceptions: These are exceptions that the compiler forces you to handle. If a method can throw a checked exception, you must either catch it using a try-catch block or declare it in the method signature using throws . Examples: IOException , SQLException . Unchecked Exceptions (Runtime Exceptions): These are exceptions that typically indicate programming errors and the compiler does not force you to handle them. While you *can* catch them, it's often better to fix the underlying bug. Examples: NullPointerException , ArrayIndexOutOfBoundsException , ArithmeticException . Errors: These are serious problems that typically cannot be recovered from by the application (e.g., OutOfMemoryError , StackOverflowError ). The application should generally not try to catch these. Special Case: The "try-with-resources" statement (Java 7+) is a special kind of try statement that automatically closes resources (like file streams or database connections) that implement the AutoCloseable interface, even if exceptions occur. This removes the need for an explicit finally block for resource management. 1.8. Generics - Type Safety and Reusability Purpose: Generics allow you to write classes, interfaces, and methods that operate on objects of various types while providing compile-time type safety. They eliminate the need for explicit type casting and reduce the risk of ClassCastException at runtime. Type Parameters: Represented by angle brackets (e.g., <T> , <E> , <K, V> ), these are placeholders for actual types that will be specified when the generic type is used. Generic Class: A class that takes type parameters (e.g., List<String> , Box<Integer> ). Generic Method: A method that introduces its own type parameters (e.g., <T> void printArray(T[] array) ). Wildcards ( ? ): Used in generic type declarations to provide flexibility in type matching. Unbounded Wildcard ( ? ): Represents an unknown type. (e.g., List<?> means a list of unknown type). Upper Bounded Wildcard ( ? extends Type ): Restricts the unknown type to be a subclass of Type (or Type itself). You can read from such a list but generally cannot add to it (except null ). Lower Bounded Wildcard ( ? super Type ): Restricts the unknown type to be a superclass of Type (or Type itself). You can add elements of Type (or its subtypes) to such a list, but reading elements out requires casting to Object . Type Erasure: A key concept in Java generics. At compile time, all generic type information is removed, and type parameters are replaced with their bounds (or Object if unbounded). This means generics are a compile-time feature for type safety, but at runtime, the JVM does not know about generic types. This is for backward compatibility with older Java versions. 1.9. Inner Classes - Classes within Classes Inner classes are classes defined within another class. They allow for tighter encapsulation and can lead to more readable and maintainable code by grouping related classes. Types of Inner Classes: Static Nested Class: This is essentially a regular class that happens to be defined inside another class, but it's marked static . It behaves like a top-level class but has access to the outer class's static members (including private ones). It does *not* have an implicit reference to an instance of the outer class, so you don't need an outer class object to create it. Non-Static Inner Class (Member Inner Class): An instance of this class is always associated with an instance of its outer class. It has implicit access to all members (static and non-static, including private) of the outer class. You must first create an object of the outer class before you can create an object of the inner class. Local Class: A class defined inside a method or any block scope. It's visible only within that block. It can access final or effectively final local variables of the enclosing block. Anonymous Class: A class without a name, defined and instantiated in a single expression. It's typically used for a one-time implementation of an interface or extension of a class. It's often used for event listeners or creating simple runnables. It can also access final or effectively final local variables of the enclosing scope. Special Case: Local variables accessed by inner classes (local or anonymous) must be final or "effectively final" (meaning their value isn't changed after initialization). This is because the inner class might outlive the method call, and it needs a stable copy of the variable. 1.10. Wrapper Classes - Bridging Primitives and Objects Purpose: Provide a way to represent primitive data types ( int , char , boolean , etc.) as objects. This is necessary because Java Collections and Generics can only store objects, not primitive types. Primitives and their Wrapper Classes: Primitive Type Wrapper Class byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean Autoboxing: The automatic conversion that the Java compiler makes between a primitive type and its corresponding wrapper class (e.g., an int value is automatically converted to an Integer object). Unboxing: The reverse process, where the compiler automatically converts a wrapper class object back to its corresponding primitive type (e.g., an Integer object is converted to an int value). Special Cases & Best Practices: Immutability: All wrapper class objects are immutable. Once created, their value cannot be changed. Comparison: Always use the .equals() method for comparing the *values* of wrapper objects. Using the == operator for wrapper objects compares their object references, which can lead to unexpected results due to object identity and caching (e.g., Integer values between -128 and 127 are often cached and may return true with == , but values outside this range often won't). NullPointerException : Attempting to unbox a null wrapper object will result in a NullPointerException . This is a common source of bugs. Performance: Frequent autoboxing/unboxing, especially within loops, can introduce performance overhead due to the creation and destruction of temporary objects. Prefer primitive types when not working with collections or generics. 1.11. The `Object` Class - The Root of All Classes All classes in Java implicitly extend java.lang.Object . It defines fundamental behaviors that all Java objects inherit. Key Methods and their Contracts: equals(Object obj) : Purpose: Defines value equality. Checks if some other object is "equal to" this one. Default Behavior: The default implementation in Object checks for object identity ( this == obj ), meaning it's only true if both references point to the exact same object in memory. Contract (when overriding): Reflexive, Symmetric, Transitive, Consistent, and equals(null) must return false . If two objects are equal, their hashCode() must be the same. hashCode() : Purpose: Returns a hash code value for the object. Used primarily by hash-based collections ( HashMap , HashSet ) to quickly determine where to store or find an object. Contract (when overriding): If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result. If two objects are unequal according to the equals(Object) method, their hash codes *do not* have to be different. However, distinct hash codes for unequal objects can improve the performance of hash tables. If an object's state isn't modified (and thus its equals comparison doesn't change), its hashCode must consistently return the same integer. toString() : Purpose: Returns a string representation of the object. Default Behavior: Returns a string that includes the class name and the object's hash code (e.g., ClassName@hashCodeInHex ). Best Practice: Should be overridden to provide a concise yet informative textual representation of the object's state. clone() : Purpose: Creates and returns a copy of this object. Mechanism: Performs a "shallow copy" by default (copies field values, but if a field is a reference to another object, only the reference is copied, not the object itself). Requirements: To use clone() , a class must implement the Cloneable marker interface and handle CloneNotSupportedException . For a "deep copy" (copying referenced objects as well), clone() must be manually overridden to perform the deep copying. getClass() : Purpose: Returns the runtime class of this Object . Mechanism: Returns a Class object, which can then be used for reflection (inspecting class metadata and behavior at runtime). notify() , notifyAll() , wait() : Used for inter-thread communication. These methods must be called from a synchronized context to prevent IllegalMonitorStateException . (Detailed in Concurrency section). == operator vs. .equals() method: A classic interview distinction. == operator: For primitive types ( int , char , boolean , etc.), it compares the actual *values*. For reference types (objects), it compares the *object references* (memory addresses). It returns true only if both references point to the exact same object in memory. .equals() method: For reference types, it compares the *content* or *state* of objects. Its default implementation in the Object class is identical to the == operator (compares references). However, it is frequently overridden in many classes (like String , Integer , ArrayList , etc.) to provide meaningful value-based comparisons. 1.12. Strings, StringBuilder, and StringBuffer String : Immutability: String objects are immutable. Once created, their content cannot be changed. Any operation that appears to modify a String (e.g., concatenation with + ) actually creates a new String object in memory. String Pool (String Interning): A special memory area within the heap where string literals are stored. When a string literal is created, the JVM first checks the string pool. If an identical string already exists, the reference to the existing string is returned; otherwise, a new string is created and added to the pool. This optimizes memory usage by avoiding duplicate strings. Creation: Literal (e.g., "hello" ): The JVM checks the string pool. new String("hello") : Always creates a new object in the heap. It might also intern "hello" into the string pool if not already present, but the reference points to the newly created heap object. StringBuilder (Introduced in Java 5): Mutability: Provides a mutable sequence of characters. Its content can be modified directly (e.g., appending, inserting, deleting characters) without creating new objects for every change. Non-Synchronized: Not thread-safe. This makes it faster than StringBuffer . Use Case: Preferred for single-threaded string manipulations where performance is critical, especially when many modifications are needed (e.g., building a complex string in a loop). StringBuffer : Mutability: Also provides a mutable sequence of characters, similar to StringBuilder . Synchronized: All its public methods are synchronized, making it thread-safe. This synchronization adds overhead, making it slower than StringBuilder . Use Case: Preferred for multi-threaded string manipulations where multiple threads might access or modify the same string buffer concurrently. Performance Consideration: For extensive string concatenation or modification within a loop, using StringBuilder or StringBuffer is significantly more efficient than repeatedly using the + operator with String , as the latter generates many intermediate, discarded String objects. 1.13. Enums (`enum`) - Type-Safe Constants Purpose: A special class type in Java used to define a fixed set of named constants. It's a type-safe and more robust way to represent a finite set of values compared to using integer constants. Key Characteristics: Constants defined in an enum are implicitly public static final . Enum constants are objects of the enum type. Enums can have fields, constructors (which must be private or package-private), and methods. This allows adding behavior to enum constants. Enums implicitly extend java.lang.Enum and cannot extend any other class. Enums can implement interfaces. Use Cases: Representing days of the week, cardinal directions, states in a state machine, log levels, command options, or any fixed set of related values. Advantages over `public static final int` constants: Type safety (prevents invalid assignments), better readability, can have behavior associated with constants, can be iterated over, and provides a clear namespace. 1.14. Local Variable Type Inference (`var` - Java 10+) Purpose: Allows local variables to be declared without explicitly specifying their type. The compiler infers the type from the initializer expression. Benefits: Reduces boilerplate code, especially with complex generic types, and can improve readability in certain contexts where the type is obvious from the right-hand side. Limitations: Only applicable to local variables, not fields, method parameters, or return types. Must be initialized at the time of declaration. Cannot be used to declare multiple variables in a single statement. Cannot be initialized with null or a lambda expression directly without a target type. The inferred type is fixed at compile time (it's not dynamic typing). Best Practice: Use when the inferred type is immediately obvious from the right-hand side and its use enhances readability. Avoid when it obscures the type or makes the code harder to understand. 1.15. Records (`record` - Java 16+) Purpose: A new type of class (a restricted form of a class) designed to model plain data aggregates concisely. They are explicitly designed to be immutable data carriers. Key Characteristics: Automatically generates a canonical constructor (matching the component list), accessor methods (named after the components, e.g., id() instead of getId() for a component id ), equals() , hashCode() , and toString() methods. All components (fields) declared in the record header are implicitly final and private . Records cannot extend any other class (they implicitly extend java.lang.Record ), but they can implement interfaces. Records cannot declare instance fields other than those declared in the record header (though static fields are allowed). Use Cases: DTOs (Data Transfer Objects), temporary data holders, return types for methods, elements in streams, or any situation where you simply need to group data. Advantages: Drastically reduces boilerplate code for data classes, improves readability, and inherently enforces immutability, making them safer for concurrent environments. 2. Collections Framework 2.1. Hierarchy - Organizing Data The Java Collections Framework (JCF) is a set of interfaces and classes for representing and manipulating collections of objects. It provides reusable data structures to store, retrieve, and process data efficiently. The root interface for most collections is java.util.Collection , which extends java.lang.Iterable . java.util.Map is a separate hierarchy because it stores key-value pairs, not just individual elements, and does not extend Collection . 2.2. Common Interfaces & Implementations List<E> : Represents an ordered collection (sequence) of elements. Elements can be accessed by their integer index. It allows duplicate elements. ArrayList : Implements List using a dynamic array. Best for fast random access ($O(1)$) and iteration. Slower for insertions/deletions in the middle of the list ($O(N)$) as it requires shifting elements. LinkedList : Implements List and Deque using a doubly linked list. Best for frequent insertions/deletions at the beginning or end ($O(1)$). Slower for random access ($O(N)$) as it requires traversing the list. Vector : A legacy class, similar to ArrayList but synchronized (thread-safe). Generally not preferred over ArrayList unless explicit synchronization is needed due to performance overhead. Set<E> : Represents a collection that contains no duplicate elements. It models the mathematical set abstraction. Element order is generally not guaranteed (unless specified by implementation). HashSet : Implements Set using a hash table. Provides $O(1)$ average-case performance for basic operations (add, remove, contains). Elements are not ordered. LinkedHashSet : Extends HashSet but maintains the insertion order of elements. TreeSet : Implements Set using a Red-Black Tree. Stores elements in sorted (ascending) order. Provides $O(\log N)$ performance for basic operations. Queue<E> : Represents a collection designed for holding elements prior to processing. Typically, elements are added at one end (the "tail") and removed from the other end (the "head"), following FIFO (First-In, First-Out) principle. LinkedList : Can be used as a Queue . PriorityQueue : Implements Queue . Elements are ordered according to their natural ordering or by a Comparator provided at construction time. It functions as a min-heap by default. Basic operations are $O(\log N)$. Deque<E> (Double-Ended Queue): Extends Queue . Supports element insertion and removal at both ends. ArrayDeque is a common and efficient implementation. Map<K,V> : Represents an object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. HashMap : Implements Map using a hash table. Provides $O(1)$ average-case performance for basic operations (get, put, remove). Keys and values are not ordered. LinkedHashMap : Extends HashMap but maintains the insertion order of key-value pairs. TreeMap : Implements Map using a Red-Black Tree. Stores key-value pairs in sorted order of keys. Provides $O(\log N)$ performance for basic operations. HashTable : A legacy class, similar to HashMap but synchronized (thread-safe) and does not allow null keys or values. Generally not preferred over ConcurrentHashMap for concurrent access. 2.3. Iterators - Traversing Collections An Iterator is an interface that provides a standard way to traverse elements in a collection, one by one. It offers methods like hasNext() (to check if there are more elements) and next() (to retrieve the next element). Iterator : The basic iterator. It also has a remove() method, which is the only safe way to remove elements from a collection during iteration without causing ConcurrentModificationException . ListIterator : A more powerful iterator specifically for List s. It allows for bidirectional traversal ( hasPrevious() , previous() ), modification ( set() ), and adding elements ( add() ) during iteration. Enhanced for-loop (for-each loop): This is syntactic sugar that works with any class that implements the Iterable interface (which Collection does). It implicitly uses an Iterator . You cannot modify the collection (add/remove elements directly) within an enhanced for-loop without risking a ConcurrentModificationException . ConcurrentModificationException : Thrown by iterators (except for some concurrent collections) when a collection is structurally modified (elements added or removed) after the iterator has been created, except through the iterator's own remove() or add() methods. This is a "fail-fast" behavior, meaning it tries to detect concurrent modifications and throw an exception rather than proceeding with an inconsistent state. 2.4. `Comparable` vs. `Comparator` - Defining Order These interfaces are used to define the sorting order of objects. Comparable<T> : Purpose: Defines the "natural ordering" for objects of a class. A class implements Comparable if its objects have an inherent, single way they should be sorted (e.g., numbers by value, strings alphabetically). Method: Requires implementing the compareTo(T other) method. This method returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. Usage: Used by methods like Collections.sort(List) or Arrays.sort(Object[]) when no Comparator is provided. Comparator<T> : Purpose: Defines an "external" or "custom" ordering. This is used when you need to sort objects in different ways, or when you are sorting objects of a class you cannot modify (e.g., a third-party class). Method: Requires implementing the compare(T obj1, T obj2) method. This method returns a negative integer, zero, or a positive integer as obj1 is less than, equal to, or greater than obj2 . Usage: Passed as an argument to sorting methods like Collections.sort(List, Comparator) or Arrays.sort(Object[], Comparator) . Special Case (Java 8+): The Comparator interface has many default and static methods (e.g., Comparator.comparing() , thenComparing() ) that make it very easy to create complex comparators using lambda expressions and method references. 2.5. Utility Classes: `Collections` and `Arrays` java.util.Collections : A utility class providing static helper methods that operate on or return collections. Sorting: Collections.sort() (using natural order or a Comparator ). Searching: Collections.binarySearch() . Synchronization: Methods like Collections.synchronizedList() , synchronizedMap() , etc., which return thread-safe (synchronized) wrappers around unsynchronized collections. Immutability: Methods like Collections.unmodifiableList() , unmodifiableMap() , etc., which return read-only views of collections. Other: reverse() , shuffle() , max() , min() , frequency() . java.util.Arrays : A utility class providing static helper methods to manipulate arrays. Sorting: Arrays.sort() (for primitives and objects, using natural order or a Comparator ). Searching: Arrays.binarySearch() . Comparing: Arrays.equals() , Arrays.deepEquals() (for nested arrays). Converting: Arrays.asList() (returns a fixed-size List view of an array), Arrays.stream() (for creating streams from arrays). Filling: Arrays.fill() . Copying: Arrays.copyOf() , System.arraycopy() . 3. Multithreading & Concurrency 3.1. Concepts - Parallel Execution Thread: The smallest unit of execution within a process. Threads share the same memory space of their parent process. They are lightweight and allow a program to perform multiple tasks concurrently. Process: An independent execution unit that has its own separate memory space. Each Java application runs in its own JVM process. Concurrency: The ability of a system to handle multiple tasks at once, seemingly executing them simultaneously. This doesn't necessarily mean true parallel execution; tasks might be interleaved on a single core. Parallelism: The actual simultaneous execution of multiple tasks on multiple processor cores. 3.2. Creating Threads - Making Your Code Concurrent There are two primary ways to create and run threads in Java: Extending the Thread class: Create a class that extends java.lang.Thread and override its run() method with the code you want to execute in the new thread. Then create an instance of your custom thread class and call its start() method. Implementing the Runnable interface: Create a class that implements java.lang.Runnable and override its run() method. Then, create an instance of your Runnable class and pass it to the constructor of a Thread object, then call the Thread object's start() method. This is generally the preferred approach because it allows your class to extend another class (Java does not support multiple inheritance for classes). It also separates the task ( Runnable ) from the thread ( Thread ). Special Case: Calling run() directly instead of start() will execute the code in the *current* thread, not in a new thread. It simply behaves like a regular method call. 3.3. Thread Lifecycle - Stages of Execution A thread goes through several states during its lifetime: New: A thread is in this state when it's created but hasn't started yet (before start() is called). Runnable: After start() is called, the thread is in this state. It's eligible to be run by the JVM scheduler, but it might not be actively executing. Running: The thread is currently executing on a processor. Blocked/Waiting/Timed Waiting: The thread is temporarily inactive and not eligible to run. Blocked: Waiting to acquire a monitor lock (e.g., waiting for a synchronized block to become available). Waiting: Waiting indefinitely for another thread to perform a particular action (e.g., calling Object.wait() or Thread.join() ). Timed Waiting: Waiting for another thread to perform an action for a specified waiting time (e.g., Thread.sleep(milliseconds) , Object.wait(milliseconds) ). Terminated: The thread has finished its execution (either naturally or due to an uncaught exception). 3.4. Synchronization - Protecting Shared Resources When multiple threads access and modify shared data concurrently, it can lead to data inconsistency or race conditions. Synchronization mechanisms are used to ensure that only one thread can access a critical section of code (shared resource) at a time. synchronized keyword: Synchronized Method: When a method is declared synchronized , calling it acquires a lock on the *object* instance (for non-static methods) or on the *class* (for static methods). Only one synchronized method (on the same object/class) can execute at a time. Synchronized Block: Provides finer-grained control. You can specify which object to lock on. This allows you to synchronize only a specific part of a method, or to synchronize on an object other than this . volatile keyword: Applied to a field, it ensures that changes to that field are immediately visible to all threads. It prevents compilers and CPUs from caching the variable's value in local registers, forcing reads and writes directly to main memory. It guarantees visibility but *not* atomicity (e.g., volatile int counter; counter++; is not atomic). Use for flags or status variables. (See Java Memory Model). wait() , notify() , notifyAll() : These are methods of the Object class, used for inter-thread communication. They must be called from within a synchronized block or method (on the same object that is being waited on/notified). Failure to do so results in an IllegalMonitorStateException . wait() : Causes the current thread to release the lock it holds on the object and go into a waiting state until another thread invokes notify() or notifyAll() on the same object, or a specified timeout expires. notify() : Wakes up a single thread that is waiting on the object's monitor. Which thread gets woken up is non-deterministic. notifyAll() : Wakes up all threads that are waiting on the object's monitor. They will then compete for the lock. Special Case (Spurious Wakeups): Threads waiting on wait() can sometimes wake up without being notified. Therefore, wait() calls should always be placed inside a loop that checks the condition it's waiting for (e.g., while (condition is not met) { wait(); } ). 3.5. Concurrency Utilities ( java.util.concurrent ) This package provides a rich set of tools for building concurrent applications, offering more flexible and powerful alternatives to basic synchronized constructs. Executors Framework: Manages thread pools, separating task submission from task execution. ExecutorService : An interface that manages a pool of worker threads. It's typically configured using Executors factory methods (e.g., newFixedThreadPool , newCachedThreadPool ). submit() : Submits a Runnable or Callable task to the executor. For Callable , it returns a Future object. execute() : Submits a Runnable task to the executor. Callable<V> and Future<V> : Callable : Similar to Runnable , but its call() method can return a result (of type V ) and throw a checked exception. Future : Represents the result of an asynchronous computation. It provides methods to check if the computation is complete, wait for its completion, and retrieve the result ( get() method, which blocks if the result is not yet available). Locks ( ReentrantLock ): Offer more control than synchronized blocks. They allow for features like trying to acquire a lock without blocking ( tryLock() ), interruptible lock acquisition, and separate read/write locks ( ReentrantReadWriteLock is a pair of ReentrantLock s for read and write operations). Semaphores: Control access to a limited number of resources. A semaphore maintains a count of available permits. Threads must acquire a permit to access a resource and release it when done. Atomic Variables: Classes like AtomicInteger , AtomicLong , AtomicReference provide atomic operations (operations that are guaranteed to complete without interruption) on single variables without needing explicit locking, using optimistic locking (compare-and-swap (CAS) operations). Concurrent Collections: Thread-safe implementations of standard collection interfaces (e.g., ConcurrentHashMap , CopyOnWriteArrayList , BlockingQueue ). They are designed for high-performance concurrent access, often using fine-grained locking or lock-free algorithms, and are generally preferred over synchronized wrappers from Collections utility class. 3.6. Deadlock - The Thread Stalemate Deadlock occurs when two or more threads are permanently blocked, each waiting for a resource that another thread in the group holds. No thread can proceed, leading to a system halt. Four Conditions for Deadlock (Coffman Conditions): For a deadlock to occur, all four conditions must be present: Mutual Exclusion: At least one resource must be held in a non-sharable mode; only one thread can use the resource at a time. Hold and Wait: A thread holding at least one resource is waiting to acquire additional resources held by other threads. No Preemption: Resources cannot be forcibly taken from a thread; they can only be released voluntarily by the thread holding them. Circular Wait: A set of waiting threads forms a closed chain, where each thread in the chain is waiting for a resource held by the next thread in the chain. Deadlock Prevention/Avoidance: Strategies to prevent one or more of the four conditions. Common methods include acquiring locks in a fixed order, using timeouts when trying to acquire locks, or ensuring all necessary resources are acquired at once. 3.7. The Java Memory Model (JMM) Purpose: Defines how threads interact with memory (main memory and CPU caches) and how changes made by one thread become visible to others. It specifies the rules for how memory operations (reads and writes) are ordered and synchronized, ensuring consistent behavior across different hardware architectures and JVM implementations. Key Concepts: Visibility: Guarantees that memory writes performed by one thread are visible to other threads. Without proper synchronization, a thread might read stale data from its CPU cache instead of the latest value from main memory. Ordering: Compilers, processors, and the JVM can reorder instructions for performance optimization. The JMM defines rules to prevent reordering that would break program correctness in concurrent scenarios. Atomicity: An operation is atomic if it completes entirely or not at all, without interruption. All primitive reads/writes (except for long and double in older JVMs, though modern JVMs usually make them atomic) are atomic. Operations on volatile variables are guaranteed to be atomic for reads and writes. `happens-before` Relationship: The cornerstone of the JMM. It is a guarantee that memory writes by one specific statement are visible to another specific statement. If action A happens-before action B, then the effects of A are visible to B, and A must complete before B begins. This relationship is established by: Program Order Rule: Within a single thread, an action happens-before any subsequent action in that same thread. Monitor Lock Rule: An unlock on a monitor happens-before a subsequent lock on the same monitor. (e.g., synchronized blocks/methods). volatile Variable Rule: A write to a volatile variable happens-before any subsequent read of that same volatile variable. Thread Start Rule: A call to Thread.start() happens-before any actions in the started thread. Thread Join Rule: All actions in a thread happen-before the successful return from a Thread.join() on that thread. Transitive Rule: If A happens-before B, and B happens-before C, then A happens-before C. Importance: Understanding JMM is crucial for writing correct and efficient concurrent code, especially when using low-level synchronization primitives like volatile or custom locks, and for debugging subtle concurrency issues. 3.8. Final vs. Finally vs. Finalize This is a common interview question due to the similar-sounding terms, but they serve entirely different purposes. final (Keyword): Purpose: A modifier used for variables, methods, and classes to indicate immutability or non-overridability. Usage: `final variable`: Its value cannot be reassigned. `final method`: Cannot be overridden by subclasses. `final class`: Cannot be subclassed (inherited). finally (Block): Purpose: A block of code associated with a try-catch statement. It guarantees that the code within it will always execute, regardless of whether an exception occurred in the try block, or was caught by a catch block. Usage: Primarily used for cleanup operations that *must* happen, such as closing file streams, database connections, or releasing locks, to prevent resource leaks. Special Case: The only time a finally block might not execute is if the JVM exits (e.g., via System.exit() ) while the try or catch block is executing, or if the thread executing the try-catch-finally block is killed. finalize() (Method): Purpose: A protected method of the Object class. It's invoked by the Garbage Collector on an object just before that object is garbage collected. It's intended to perform cleanup actions before an object is permanently removed from memory. Usage: Overridden by classes that need to clean up non-Java resources (like native memory pointers, file handles opened via JNI) before the object is destroyed. Special Case (Discouraged): The finalize() method is generally discouraged in modern Java development. Its execution is not guaranteed, nor is its timing predictable. It can even cause performance issues or prevent objects from being garbage collected if not implemented carefully. The "try-with-resources" statement and explicit cleanup methods are preferred for resource management. 3.9. Class Loading and ClassLoaders Class Loading: The dynamic process by which the Java Virtual Machine (JVM) loads classes into memory at runtime. This process involves three main phases: Loading, Linking, and Initialization. ClassLoaders: Are responsible for locating and loading class files. Java uses a hierarchical delegation model for classloaders: Bootstrap ClassLoader (Primordial ClassLoader): Loads core Java API classes (e.g., from rt.jar or the Java runtime modules). It's implemented in native code and is the parent of all other classloaders. Extension ClassLoader (Platform ClassLoader - Java 9+): Loads classes from the JDK's extensions directory ( jre/lib/ext in older Java, or platform modules in Java 9+). Child of the Bootstrap ClassLoader. Application ClassLoader (System ClassLoader): Loads classes from the application's classpath (specified by the -classpath or -cp option). Child of the Extension/Platform ClassLoader. Custom ClassLoaders: Developers can create their own classloaders by extending java.lang.ClassLoader for specific needs, such as loading classes from a network, hot-swapping classes, or isolating different application components. Delegation Model: When a classloader is asked to load a class, it first delegates the request to its parent classloader. Only if the parent cannot find or load the class, the current classloader attempts to locate and load the class itself. This model ensures that core Java classes are always loaded by the Bootstrap ClassLoader, preventing malicious code from replacing fundamental Java components. Loading Phase: Finds the binary form of a class or interface (e.g., .class file) and creates a Class object in the method area. Linking Phase: Verification: Ensures the bytecode is well-formed and adheres to JVM specifications. Preparation: Allocates memory for static fields and initializes them to default values. Resolution: Replaces symbolic references (e.g., to other classes/methods) with direct references. Initialization Phase: Executes the class's static initializers (static blocks and static field assignments) in the order they appear in the source code. This happens only once for a class. 4. Java 8+ Features - Modern Java Java 8 introduced significant features that moved the language towards a more functional programming style, enhancing productivity and enabling more concise code. Lambda Expressions: Provide a concise syntax for implementing functional interfaces (interfaces with a single abstract method). They allow you to treat functionality as a method argument, enabling more functional-style programming. Syntax: (parameters) -> { body } . Stream API: A powerful API for processing collections of data (sequences of elements). It supports declarative, functional-style operations on streams, which can be processed sequentially or in parallel. Intermediate Operations: Return a new stream (e.g., filter() , map() , sorted() , distinct() ). They are lazy; they don't execute until a terminal operation is called. Terminal Operations: Produce a result or a side-effect (e.g., forEach() , collect() , reduce() , count() , min() , max() ). They trigger the processing of intermediate operations. Default Methods in Interfaces: Allow adding new methods with implementations to interfaces without affecting existing classes that implement that interface. This solves the "diamond problem" by requiring explicit override if multiple interfaces provide the same default method. Static Methods in Interfaces: Utility methods that belong to the interface itself, not to any specific implementation. They cannot be inherited or overridden. Optional Class: A container object that may or may not contain a non-null value. It's designed to reduce the number of NullPointerException s by forcing developers to explicitly handle the absence of a value. It provides methods like isPresent() , orElse() , ifPresent() , and map() . Method References: A concise way to refer to methods or constructors without executing them. They are syntactic sugar for lambda expressions that simply call an existing method. Static method: ClassName::staticMethod Instance method of a particular object: object::instanceMethod Instance method of an arbitrary object of a particular type: ClassName::instanceMethod Constructor: ClassName::new Date and Time API ( java.time package): A completely new, immutable, and thread-safe API for handling dates and times, addressing many shortcomings of the old java.util.Date and Calendar classes. Key classes include LocalDate , LocalTime , LocalDateTime , ZonedDateTime , Duration , and Period . 5. Input/Output (I/O) Java's I/O system is stream-based, meaning data is read from or written to a continuous sequence of data. Streams: Byte Streams: Handle raw binary data (e.g., images, sound files). The base classes are InputStream and OutputStream . Examples: FileInputStream , FileOutputStream . Character Streams: Handle text data, automatically managing character encodings (e.g., UTF-8). The base classes are Reader and Writer . Examples: FileReader , FileWriter , BufferedReader , BufferedWriter . Buffered Streams: (e.g., BufferedReader , BufferedWriter ) Wrap around other streams to improve performance by reading/writing blocks of data at a time rather than single bytes/characters. Scanner : A versatile utility for parsing primitive types and strings from various input sources (like System.in , files). Serialization: The process of converting an object's state into a byte stream, which can then be stored (e.g., in a file) or transmitted across a network. The object must implement the java.io.Serializable marker interface. Deserialization is the reverse process, reconstructing the object from the byte stream. serialVersionUID : A unique identifier for a Serializable class. Used during deserialization to ensure that the sender and receiver have loaded classes for the object that are compatible with respect to serialization. If omitted, the JVM generates one, which can change upon class modification and break deserialization of older serialized objects. Providing an explicit serialVersionUID helps manage backward compatibility. Custom Serialization: Methods like private void writeObject(ObjectOutputStream out) and private void readObject(ObjectInputStream in) can be defined within a Serializable class to control the serialization process, allowing for encryption, compression, or handling transient fields. Special Case: The "try-with-resources" statement (discussed in Exception Handling) is particularly useful for I/O operations as it ensures that streams are properly closed, even if errors occur, by implementing the AutoCloseable interface. 6. Memory Management and Garbage Collection Automatic Memory Management: Java manages memory automatically, relieving developers from manual memory allocation and deallocation (unlike languages like C++). This is primarily handled by the Garbage Collector. Garbage Collector (GC): A daemon thread running in the JVM that automatically reclaims memory occupied by objects that are no longer referenced (reachable) by the running program. This prevents memory leaks to a large extent. How it Works (Conceptual): Reachability: An object is considered "garbage" if it is no longer "reachable" from any live thread. Reachable objects are those that can be accessed directly or indirectly from GC roots (e.g., active thread stacks, static fields, JNI references). Mark-and-Sweep: A common GC algorithm. Mark Phase: The GC identifies all reachable objects starting from the GC roots and marks them. Sweep Phase: The GC then iterates through the heap and reclaims memory from all unmarked (unreachable) objects. Generational GC: Most modern JVMs use generational garbage collection. This is based on the observation that most objects die young ("weak generational hypothesis"). The heap is divided into: Young Generation: New objects are allocated here (specifically in the Eden Space). Objects that survive multiple minor GCs (i.e., are still reachable) are moved to Survivor Spaces and eventually promoted to the Old Generation. Minor GC runs frequently here and is typically fast. Old Generation (Tenured Space): Stores long-lived objects that have survived many minor GCs. Major GC (or Full GC) runs less frequently here and involves more overhead. Permanent Generation (PermGen - Java 7-): Used to store metadata about classes and methods. Removed in Java 8 and replaced by **Metaspace**. Metaspace (Java 8+): Stores class metadata, replacing PermGen. It's allocated from native memory and can grow dynamically. Stop-the-World Events (STW): During certain GC cycles (especially Full GCs), all application threads may be paused to ensure a consistent view of the heap. These pauses are called "Stop-the-World" events and can impact application performance, especially for large heaps. Modern GCs aim to minimize these pauses. Common GC Algorithms (JVM Options): Serial GC (`-XX:+UseSerialGC`): Simplest, single-threaded, "stop-the-world" for all phases. Suitable for small applications or single-processor machines. Parallel GC (`-XX:+UseParallelGC`): Multi-threaded, "stop-the-world" for young and old generation collections. Aims for high throughput (maximizes CPU utilization for application code). CMS (Concurrent Mark-Sweep) GC (`-XX:+UseConcMarkSweepGC`): Designed for low latency. Most work is done concurrently with application threads, minimizing "stop-the-world" pauses. Deprecated in Java 9, removed in Java 14. G1 (Garbage-First) GC (`-XX:+UseG1GC`): Default since Java 9. Divides the heap into regions. Prioritizes collecting regions with the most garbage first to meet user-defined pause time goals. Operates concurrently, in parallel, and is generational. ZGC (Z Garbage Collector - Java 11+, `-XX:+UseZGC`), Shenandoah (Java 12+, `-XX:+UseShenandoahGC`): Low-latency, highly scalable GCs designed for very large heaps (terabytes) and extremely short pause times (milliseconds or less), even with large heaps. Prioritize low latency. When GC Runs: The GC runs automatically when the JVM determines that memory is running low. You cannot force the GC to run; System.gc() is merely a hint to the JVM, which it may or may not heed. Object Finalization ( finalize() method): A method that the Garbage Collector calls on an object just before it's garbage collected. Special Case: Generally discouraged. It's not guaranteed to run, or to run in a timely manner. It can even prevent objects from being garbage collected if not implemented carefully. It's better to use try-with-resources or explicit cleanup methods for resource management. Memory Leaks in Java: While GC handles memory automatically, "memory leaks" can still occur if objects are no longer needed but are still reachable (e.g., an object is removed from a collection but a static reference to it still exists, preventing GC). This is often caused by improper management of object references. Memory Areas in JVM: Heap: Where all objects and arrays are stored. This is the primary area managed by the Garbage Collector. Stack: Each thread has its own private JVM stack. Stores local variables, method call frames, and partial results. Managed by the JVM (not GC). Method Area (Metaspace - Java 8+ / PermGen - Java 7-): Stores class structures, method data, static variables, bytecode, constant pool. PC Registers: Each thread has its own Program Counter (PC) Register, which stores the address of the current instruction being executed for that thread. Native Method Stacks: Used to support native methods (written in languages like C/C++). 7. Advanced Java Concepts 7.1. Reflection API Purpose: Allows a Java program to inspect and modify its own structure (classes, methods, fields) at runtime. This includes getting information about classes, creating new objects, invoking methods, and accessing/modifying fields, even private ones, dynamically. Use Cases: Frameworks (e.g., Spring, Hibernate, JUnit) widely use reflection for dependency injection, ORM mapping, and test discovery. IDEs, serialization/deserialization libraries, and code analysis tools also rely on it. Drawbacks: Performance Overhead: Reflection operations are generally slower than direct code access. Breaks Encapsulation: Allows access to private members, potentially violating design principles. Security Implications: Can bypass security checks if not managed carefully. Compilation Errors: Operations are resolved at runtime, so compile-time type checking is lost. 7.2. Annotations (Expanded) Purpose: Provide metadata about code. They do not directly affect program execution but can be processed by tools, compilers, or runtime environments. They are a form of "metadata programming." Built-in Annotations: @Override , @Deprecated , @SuppressWarnings , @FunctionalInterface . Custom Annotations: You can create your own annotations using the @interface keyword. They can have elements (like method parameters) and can be marked with meta-annotations that specify their usage: @Retention : Specifies how long annotations are to be retained (available). RetentionPolicy.SOURCE : Discarded by the compiler. RetentionPolicy.CLASS : Stored in the .class file but not available at runtime via reflection. RetentionPolicy.RUNTIME : Stored in the .class file and available at runtime via reflection (most common for frameworks). @Target : Indicates the contexts in which an annotation type is applicable (e.g., ElementType.TYPE for classes/interfaces, ElementType.METHOD , ElementType.FIELD , ElementType.PARAMETER ). @Documented : Indicates that annotations with a type should be documented by Javadoc. @Inherited : Indicates that an annotation type is automatically inherited by subclasses from their superclass. @Repeatable (Java 8+): Indicates that the annotation can be applied multiple times to the same declaration. Use Cases: Configuration (e.g., Spring annotations for dependency injection, REST endpoints), testing frameworks (JUnit annotations for test methods), code generation, documentation, static analysis. 7.3. Java Native Interface (JNI) Purpose: Allows Java code running in a JVM to call and be called by native applications and libraries written in other languages (like C, C++, Assembly). Use Cases: When performance is critical and native code offers a significant advantage (e.g., graphics processing, scientific computations). Accessing hardware-specific features or operating system services not directly available through Java APIs. Integrating with existing legacy native libraries. Drawbacks: Complexity: JNI code is intricate to write and debug. Platform Dependency: Native libraries are platform-specific, making the Java application less portable. Security Risks: Native code can introduce security vulnerabilities and memory management issues (e.g., buffer overflows) that Java's safety features typically prevent. Performance Overhead: The overhead of calling native methods can sometimes negate the performance benefits of native code for small, frequent calls. 7.4. Java Platform Module System (JPMS / Project Jigsaw - Java 9+) Purpose: Aims to make the Java platform more modular, scalable, and secure. It introduces the concept of "modules" to organize code into self-contained units. Modules: A named, self-describing collection of code (packages, classes, resources) and data. A module explicitly states its dependencies on other modules and what packages it exports for use by other modules. This is defined in a module-info.java file. Benefits: Strong Encapsulation: Only explicitly exported packages are visible to other modules. Internal implementations are hidden by default, preventing accidental or malicious access. Reliable Configuration: The JVM verifies all module dependencies at startup, ensuring that all necessary modules are present and resolving potential conflicts. Improved Performance: Allows for optimizing the runtime environment by including only the necessary modules, leading to smaller applications and faster startup times. Better Security: Reduces the attack surface by hiding internal APIs. Enhanced Maintainability: Clearly defined module boundaries make it easier to understand, maintain, and evolve large applications. 8. Best Practices & Design Patterns SOLID Principles: A set of five design principles intended to make software designs more understandable, flexible, and maintainable. S ingle Responsibility Principle: A class should have only one reason to change (i.e., it should have only one primary responsibility). O pen/Closed Principle: Software entities (classes, modules, functions) should be open for extension, but closed for modification. You should be able to add new functionality without changing existing, working code. L iskov Substitution Principle: Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program. This implies that subtypes must not break the contracts of their supertypes. I nterface Segregation Principle: Clients should not be forced to depend on interfaces they do not use. Instead of one large, general-purpose interface, prefer multiple smaller, client-specific interfaces. D ependency Inversion Principle: Depend upon abstractions, not concretions. High-level modules should not depend on low-level modules; both should depend on abstractions. Abstractions should not depend on details; details should depend on abstractions. Design Patterns: Reusable solutions to common problems in software design. They are not ready-to-use code, but rather templates for how to solve problems. Creational Patterns: Deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. (e.g., Singleton, Factory Method, Abstract Factory, Builder, Prototype). Structural Patterns: Deal with the composition of classes and objects. (e.g., Adapter, Decorator, Facade, Proxy, Composite, Bridge, Flyweight). Behavioral Patterns: Deal with the communication between objects. (e.g., Observer, Strategy, Iterator, Command, Template Method, State, Chain of Responsibility, Memento, Visitor). Immutability: Refers to objects whose state cannot be modified after they are created. Immutable objects are inherently thread-safe, easier to reason about, and can be used as keys in maps or elements in sets without issues. Examples in Java include String and all primitive wrapper classes ( Integer , Long , etc.). To create an immutable class: declare the class final , make all fields private final , don't provide setter methods, and ensure any mutable object fields are defensively copied during construction. Defensive Programming: Writing code that anticipates potential errors or invalid inputs. This includes validating method parameters, handling null checks, managing exceptions gracefully, and checking boundary conditions, to ensure robust and reliable software.