Java Basics

📖 Deep Concepts

🧠 Section 1: What is Java?

Java is a high-level, object-oriented, platform-independent programming language developed by Sun Microsystems (now owned by Oracle). It is designed to run on any device via the Java Virtual Machine (JVM), making it a Write Once, Run Anywhere language.

🔹 Key Characteristics:

• Compiled + Interpreted (Bytecode + JVM)



• Strongly typed and statically typed



• Garbage-collected



• Supports multithreading



• Rich standard library (Java API)

✅ Java Program Flow:

1. You write .java files → compiled to .class bytecode



2. JVM loads the .class files



3. Bytecode is interpreted or JIT-compiled by JVM



4. Output is shown on your terminal or GUI

🧠 Section 2: Java Compilation & Execution Flow

🔄 Diagram:

Your Code (.java)
   ↓ [javac]
Bytecode (.class)
   ↓ [java]
JVM → ClassLoader → Bytecode Verifier → Interpreter / JIT Compiler → OS Execution

☑️ Notes:

• javac is the Java compiler



• java runs the class via JVM



• JVM verifies bytecode for security and integrity



• HotSpot JVM uses Just-In-Time (JIT) compilation for performance

🧠 Section 3: Java Platform Components

🧠 Section 4: Java Editions

🧠 Section 5: Java Data Types Overview

➤ Primitive Types:

• byte (8-bit), short, int, long



• float, double



• char



• boolean

➤ Reference Types:

• Classes



• Interfaces



• Arrays

🔍 All primitives are stored in stack memory. Reference types are stored on heap.

🧠 Section 6: Java Keywords, Syntax & Program Structure

🔑 Reserved Keywords in Java:

Java has a set of reserved words that have predefined meanings and cannot be used as identifiers (variable/class names).

🧱 Java Program Structure

// HelloWorld.java
public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello, World!");

    

}



}

💡 Structure Breakdown:

• public class HelloWorld: Class definition



• public static void main(String[] args): Entry point of the program



• System.out.println: Outputs text to the console

⚙️ Syntax Rules:

• Every application starts from the main() method



• Class names must match the file name (case-sensitive)



• Statements end with ;



• Code blocks are enclosed in { }



• Java is case-sensitive (MyVar ≠ myvar)

📖 Deep Concepts

🧠 Section 7: Object-Oriented Programming (OOP) in Java

Java is a fully object-oriented language (except for primitives), designed to model the real world using classes and objects. OOP promotes modularity, reusability, and abstraction, which are essential for scalable system design.

🔹 4 Pillars of OOP in Java:

1. Encapsulation – Wrap data and methods in a single unit (class)
2. Abstraction – Show only essential details; hide internal logic
3. Inheritance – Acquire properties of another class (IS-A relationship)
4. Polymorphism – One interface, multiple implementations (overloading, overriding)

✅ Encapsulation Example:

public class Account {

    private int balance;


    public int getBalance() {
 return balance;
 

}

    public void deposit(int amount) {

        if (amount > 0) balance += amount;

    

}



}

Why: Protects internal data. External classes can't change balance directly.

✅ Abstraction Example (using interface):

interface Vehicle {

    void start();



}


class Car implements Vehicle {

    public void start() {

        System.out.println("Car started");

    

}



}

Why: Client code depends on the Vehicle abstraction, not the specific implementation (Car).

✅ Inheritance Example:

class Animal {

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

}



}


class Dog extends Animal {

    void sound() {
 System.out.println("Bark");
 

}



}

Why: Promotes code reuse and extension of common behavior.

✅ Polymorphism (Method Overriding & Overloading):

// Overloading (compile-time polymorphism)
void print(int x) {
 ... 

}

void print(String s) {
 ... 

}


// Overriding (runtime polymorphism)
Animal a = new Dog();

a.sound();
 // "Bark"

Why: Same method name behaves differently based on context or type.

🧠 Section 8: Java Classes, Objects & Memory Model

📦 What is a Class?

A class in Java is a blueprint or template that defines the structure and behavior (fields and methods) of objects.

class Car {

    String model;

    void drive() {

        System.out.println("Car is driving...");

    

}



}

🧍‍♂️ What is an Object?

An object is a real-world instance of a class. It is created using the new keyword.

Car myCar = new Car();

Here, myCar is an object of the class Car.

🧠 Java Memory Model (JMM)

Java uses a structured memory model divided mainly into two runtime areas:

• Stack Memory: Stores method calls and primitive/local variables. Each thread has its own stack.
• Heap Memory: Stores all objects and class-level variables (fields).

Example:

class Book {

    String title;



}


Book b1 = new Book();
 // 'b1' → stack, 'new Book()' → heap

The reference variable b1 lives in the stack, but the object it refers to is on the heap.

🔄 Object Lifecycle

1. Declaration → Book b;
2. Instantiation → new Book();
3. Initialization → via constructors
4. Usage → method calls, field access
5. Garbage Collection → object is removed if no references exist

Note: Java uses mark-and-sweep garbage collection under the hood (e.g., G1GC, ZGC).

🧭 'this' Keyword in Java

this refers to the current instance of the class.

class Student {

    String name;

    Student(String name) {

        this.name = name;
 // distinguishes field from constructor param
    

}



}

🧱 Constructors in Java

Constructors are special methods used to initialize new objects. If no constructor is defined, Java provides a default one.

class Pen {

    String color;

    Pen(String c) {

        color = c;

    

}



}

🧯 Garbage Collection & finalize()

The JVM automatically cleans unreachable objects using Garbage Collection. You can override finalize() for cleanup, though it is deprecated from Java 9+.

@Override
protected void finalize() throws Throwable {

    System.out.println("Object is destroyed");



}

Tip: Use try-with-resources or finally block instead for safe cleanup.

🧠 Section 9: Access Modifiers, Packages & Visibility Rules in Java

🔐 1. What Are Access Modifiers?

Access modifiers control the visibility of classes, variables, methods, and constructors across packages and inheritance chains. They enforce encapsulation, which is a core OOP principle.

💡 2. Best Practices

• Use private for fields and helper methods.
• Use protected only if you expect inheritance.
• Use public only for API contracts.
• Default access is preferred within small modules/packages.

🔁 3. Package-Level Access (default)

If you don’t specify a modifier, the member has package-private access — accessible only within the same package.

// Same package
class Service {

    void logInfo() {
 ... 

}
  // default access


}

📦 4. What Are Packages in Java?

A package is a namespace that organizes a set of related classes and interfaces. It also prevents naming conflicts and controls visibility using the access rules above.

package com.bank.loan;


public class LoanService {

    public void applyLoan() {
 ... 

}



}

🧩 5. Subpackages ≠ Same Package

Java treats subpackages as completely separate packages, even if they share a parent. Access modifiers work independently across them.

// com.example.a.ClassA
package com.example.a;

public class ClassA {

    protected void show() {
 System.out.println("A");
 

}



}


// com.example.a.b.ClassB
package com.example.a.b;

public class ClassB extends ClassA {

    // Cannot access show() unless imported and subclassed correctly


}

📥 6. Importing Classes

You can import classes from other packages using import statements:

import java.util.List;

import com.company.product.service.ProductService;

• import package.* brings in all classes (not subpackages!)
• Use import static for static fields/methods

import static java.lang.Math.*;
 // now you can use sqrt(), pow() directly

📁 7. Package Structure in Real Projects

Use packages to modularize your code logically:

• com.company.app.controller → HTTP controllers
• com.company.app.service → Business logic
• com.company.app.model → Domain models
• com.company.app.util → Helpers, constants

🔒 8. Nested Class Access Modifiers

Inner/nested classes can also use access modifiers:

public class Outer {

    private class Inner1 {
 

}
     // accessible only inside Outer
    protected class Inner2 {
 

}
   // visible to subclasses
    public static class Inner3 {
 

}
 // accessible outside


}

🧠 Section 10: Control Flow in Java

🔁 1. Conditional Branching: if, else if, else

Control flow allows you to make decisions in Java programs using conditional and loop constructs.

int score = 85;


if (score >= 90) {

    System.out.println("Excellent");



}
 else if (score >= 75) {

    System.out.println("Very Good");



}
 else {

    System.out.println("Keep Practicing");



}

✅ Useful in CP for checking input constraints or branching logic.

🔄 2. switch-case (Java 7+)

Switch is preferred over multiple if-else when comparing the same variable against many values.

int day = 2;

switch (day) {

    case 1: System.out.println("Monday");
 break;

    case 2: System.out.println("Tuesday");
 break;

    default: System.out.println("Other Day");



}

✅ Avoids repetitive `if` chains. CP-friendly for command menus or key mappings.

🔁 3. Loops: for, while, do-while

• for: used when range is known
• while: used when condition-based execution is needed
• do-while: executes once, even if condition is false

// for loop example
for (int i = 0;
 i < 5;
 i++) {

    System.out.print(i + " ");



}


// while loop
int n = 5;

while (n > 0) {

    System.out.print(n + " ");

    n--;



}

✅ Loops are the heart of all DSA logic like traversals, simulations, and brute-force solutions.

🔖 4. Loop Labels in Java

Loop labels allow precise control of which loop to break or continue, especially in nested loops.

outer:
for (int i = 1;
 i <= 3;
 i++) {

    for (int j = 1;
 j <= 3;
 j++) {

        if (i == 2 && j == 2)
            break outer;

        System.out.println(i + " " + j);

    

}



}

✅ break outer; immediately stops the outer loop. Without labels, only the inner loop would stop.

⛔ 5. `break` Statement

Used to exit a loop (or switch) immediately.

for (int i = 0;
 i < 10;
 i++) {

    if (i == 5) break;

    System.out.print(i + " ");



}

✅ Output: 0 1 2 3 4

↩️ 6. `continue` Statement

Skips the current iteration and continues with the next one.

for (int i = 1;
 i <= 5;
 i++) {

    if (i == 3) continue;

    System.out.print(i + " ");



}

✅ Output: 1 2 4 5 — Skips printing 3

🛑 7. `return` Statement

Exits from the current method immediately.

public void greet(String name) {

    if (name == null) return;

    System.out.println("Hello " + name);



}

✅ Especially useful in input validations or early exits in recursive/utility functions.

⌨️ 8. Fast I/O Templates for Competitive Programming

Java's default I/O (e.g., Scanner) is slow for large inputs. Use BufferedReader and PrintWriter for faster I/O.

import java.io.*;

import java.util.*;


public class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in)
        );

        PrintWriter out = new PrintWriter(System.out);

        
        int n = Integer.parseInt(br.readLine());

        String[] parts = br.readLine().split(" ");

        int[] arr = new int[n];

        
        for (int i = 0;
 i < n;
 i++) {

            arr[i] = Integer.parseInt(parts[i]);

        

}

        
        for (int x : arr) out.print(x + " ");

        out.flush();

    

}



}

✅ Suitable for contests like Codeforces, AtCoder, Leetcode Weekly, etc.

• ⏱️ Reduces TLE risk on large inputs
• 📥 Read inputs in batch format (e.g., read full line then split)
• 🚀 Use StringTokenizer when input format is consistent

🧠 Section 11: Arrays, Strings & Collections

📌 Overview

This section introduces Java’s most critical data structures for DSA and competitive programming:

• Arrays (fixed size)
• Strings (immutable character sequences)
• Collections (ArrayList, LinkedList, HashSet, HashMap, TreeMap, etc.)

Mastering these data structures is crucial for performance-oriented development and algorithmic problem solving.

🔹 Arrays in Java

int[] arr = new int[5];
    // default 0
arr[0] = 10;


String[] names = {
"Alice", "Bob"

}
;

✅ Arrays are indexed, fixed-length containers with O(1) access. 🔸 Used when size is known and access is frequent.

🔹 Strings in Java

String s = "hello";

String t = new String("hello");
 // not recommended

System.out.println(s.charAt(1));
 // 'e'

✔️ Strings are immutable. Concatenation creates new objects unless using StringBuilder.

// Efficient string building
StringBuilder sb = new StringBuilder();

sb.append("Java");

sb.append(" Rocks");

System.out.println(sb.toString());

🚀 StringBuilder is O(1) for appending, whereas + is O(n).

🔹 Collections Hierarchy

Java Collections Framework provides scalable alternatives to arrays:

• List: Ordered, index-based (ArrayList, LinkedList)
• Set: Unique elements (HashSet, TreeSet)
• Map: Key-value pairs (HashMap, TreeMap)

// List Example
List<String> list = new ArrayList<>();

list.add("a");

list.add("b");


// Map Example
Map<String, Integer> map = new HashMap<>();

map.put("one", 1);

map.put("two", 2);

⏱️ Choose wisely:

• ArrayList = fast access, slow insert/delete in middle
• LinkedList = slow access, fast insert/delete at ends
• HashMap = O(1) average key lookup

🔍 HashMap Internal Working (Java 8+)

HashMap is one of the most used data structures in Java for fast key-value lookup, insertion, and deletion. It works on the principle of hashing and bucket indexing.

📦 Internally, a HashMap uses an array of buckets:

transient Node<K,V>[] table;

• Each bucket may contain a single node or a linked list of entries.
• Java 8+ converts buckets to a red-black tree when collisions exceed a threshold (TREEIFY_THRESHOLD = 8).

⚙️ How Key Lookup Works:

1. Calculate hashCode() of the key.
2. Apply supplemental hash (bit shifting) for better spread.
3. Use hash % capacity (via bit mask) to find bucket index.
4. Compare entries in the bucket using equals().

int hash = key.hashCode();

int index = (n - 1) & hash;

🚨 Collision handling is done using chaining (linked list or tree).

🧪 Custom Class as Key: Always Override hashCode() and equals()

class Student {

    int id;

    String name;


    @Override
    public int hashCode() {

        return Objects.hash(id);
 // or: return id;

    

}


    @Override
    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Student that = (Student) o;

        return id == that.id;

    

}



}

✅ Rule: If two objects are equal (equals → true), their hashCodes must match. ⚠️ But two objects with the same hashCode can still be unequal.

📈 Resizing and Threshold

• Initial capacity = 16 (default), load factor = 0.75
• Resize triggers when size > capacity × load factor (i.e., 12 for default)
• New table size = old size × 2

map.put("key13", "value13");
 // may cause resize

🔄 Resizing is expensive – all existing entries are rehashed into the new table.

🧠 Why Use `final` or `immutable` keys in Maps?

If the key object changes (e.g., ID changes), the hashCode might change and make the key unreachable!

// BAD: mutable key
Student s = new Student(1, "A");

map.put(s, "Grade A");


s.id = 2;
 // Now s.hashCode() changed!
map.get(s);
 // null

✅ Best Practice: Use immutable classes as keys (e.g., String, Integer).

📌 Summary Tips

• Always override equals() and hashCode() when using custom keys
• Avoid frequent rehashing by setting initial capacity wisely
• Use LinkedHashMap to preserve insertion order
• Use TreeMap if you need sorted keys (uses Red-Black Tree)

🧠 Section 12: Exception Handling – Part 1

📌 What is Exception Handling in Java?

Exception handling is Java’s way to manage runtime errors, ensuring the program doesn't crash unexpectedly and providing a structured way to respond to abnormal situations.

⚠️ What is an Exception?

An exception is an event that disrupts the normal flow of program execution. It is an object that encapsulates information about the error.

✅ Basic try-catch Syntax

try {

    // Code that might throw an exception
    int result = 10 / 0;



}
 catch (ArithmeticException e) {

    System.out.println("Cannot divide by zero!");



}

🔍 Explanation: Any exception thrown inside the try block is caught by the catch block, and the flow continues.

🔁 finally Block

The finally block always runs, whether or not an exception occurred. It's commonly used for closing resources.

try {

    FileReader fr = new FileReader("data.txt");

    // read file


}
 catch (IOException e) {

    e.printStackTrace();



}
 finally {

    System.out.println("Cleanup code, like closing file");



}

💡 Best Practice: Always Use finally for Cleanup

Avoid resource leaks (e.g., unclosed files, DB connections) by placing cleanup logic in finally or using try-with-resources in Java 7+.

🧠 Section 12: Exception Handling – Part 2: throw vs throws

🚀 Difference Between throw and throws

Though similar in syntax, throw and throws are used for entirely different purposes in Java.

📌 throw – Used to Throw an Exception

throw is used inside a method or block to actually throw an instance of an Exception.

public class ThrowExample {

  public static void main(String[] args) {

    throw new ArithmeticException("Division by zero not allowed!");

  

}



}

✅ Note: Only one exception can be thrown at a time using throw.

📌 throws – Declares an Exception

throws is used in method signature to declare that the method may throw one or more exceptions, and caller must handle them.

public void readFile() throws IOException {

  FileReader fr = new FileReader("data.txt");



}

✅ Note: Multiple exceptions can be declared using comma:

public void process() throws IOException, SQLException {
 
  // risky code 


}

🔍 Comparison Table

💡 Best Practice:

• Use throw to raise custom exceptions with meaningful messages.
• Use throws to allow upper-level methods to handle exceptions cleanly.

📚 Real-World Example

// Custom Exception
class BankException extends Exception {

  public BankException(String message) {

    super(message);

  

}



}


public class ATM {

  public void withdraw(int balance, int amount) throws BankException {

    if (amount > balance) {

      throw new BankException("Insufficient Balance!");

    

}

    System.out.println("Withdrawal Successful");

  

}


  public static void main(String[] args) {

    ATM atm = new ATM();

    try {

      atm.withdraw(500, 800);

    

}
 catch (BankException e) {

      System.out.println(e.getMessage());

    

}

  

}



}

🧠 Section 12: Exception Handling – Part 3: Checked vs Unchecked Exceptions

📌 What are Checked Exceptions?

Checked exceptions are the exceptions that must be either caught using try-catch or declared using throws in the method signature.

public void readFile(String path) throws IOException {

  FileReader reader = new FileReader(path);
 // May throw IOException


}

✅ Examples: IOException, SQLException, FileNotFoundException, etc.

📌 What are Unchecked Exceptions?

Unchecked exceptions are not checked at compile time. These typically occur due to bugs in the code, and do not require explicit try-catch or throws declaration.

public void divide(int a, int b) {

  int result = a / b;
 // Might throw ArithmeticException


}

✅ Examples: NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException

🔍 Comparison Table

📘 Code Example: Both in One Program

import java.io.*;


public class ExceptionTypes {


  // Checked exception method
  public static void loadFile(String name) throws FileNotFoundException {

    FileReader fr = new FileReader(name);

  

}


  // Unchecked exception method
  public static void divide(int x, int y) {

    int z = x / y;
 // May throw ArithmeticException
  

}


  public static void main(String[] args) {

    try {

      loadFile("data.txt");

    

}
 catch (FileNotFoundException e) {

      System.out.println("Handled Checked Exception: " + e.getMessage());

    

}


    try {

      divide(10, 0);

    

}
 catch (ArithmeticException e) {

      System.out.println("Handled Unchecked Exception: " + e.getMessage());

    

}

  

}



}

✅ Best Practice:

• Always handle checked exceptions explicitly to avoid crashes.
• Use unchecked exceptions for developer errors (e.g., null checks).
• Never ignore exceptions silently. Log or propagate!

🧠 Section 12: Exception Handling – Part 4: Best Practices

🔍 Why Exception Handling Matters

In large-scale applications, robust exception handling is essential to ensure graceful error recovery, debugging, and better user experience. Following best practices avoids silent failures or unnecessary crashes.

✅ Best Practice #1: Catch Specific Exceptions

// ❌ Bad: Catching generic Exception
try {

  riskyOperation();



}
 catch (Exception e) {

  e.printStackTrace();



}


// ✅ Good: Catch only what you're expecting
try {

  riskyOperation();



}
 catch (IOException e) {

  System.err.println("File I/O error: " + e.getMessage());



}

✅ Best Practice #2: Never Swallow Exceptions Silently

// ❌ Bad: Empty catch block
try {

  doSomething();



}
 catch (Exception e) {

  // Ignored


}


// ✅ Good: Log or propagate
try {

  doSomething();



}
 catch (Exception e) {

  System.err.println("Error occurred: " + e.getMessage());



}

✅ Best Practice #3: Don’t Overuse Checked Exceptions

Too many checked exceptions in APIs make code harder to read and maintain. Prefer unchecked exceptions for programming logic errors.

✅ Best Practice #4: Never Use Exceptions for Flow Control

// ❌ Anti-pattern
try {

  int x = Integer.parseInt(input);



}
 catch (NumberFormatException e) {

  x = 0;
 // Don't do this for regular logic


}


// ✅ Preferred
if (input.matches("\\d+")) {

  int x = Integer.parseInt(input);



}
 else {

  x = 0;



}

✅ Best Practice #5: Clean Up Resources with finally / try-with-resources

// Using finally
FileReader fr = null;

try {

  fr = new FileReader("file.txt");

  // read file


}
 catch (IOException e) {

  e.printStackTrace();



}
 finally {

  if (fr != null) fr.close();



}


// Preferred: try-with-resources
try (FileReader fr2 = new FileReader("file.txt")) {

  // read file


}
 catch (IOException e) {

  e.printStackTrace();



}

✅ Best Practice #6: Create Custom Exceptions for Domain Logic

// Define
public class InsufficientBalanceException extends Exception {

  public InsufficientBalanceException(String msg) {

    super(msg);

  

}



}


// Use
if (balance < withdrawAmount) {

  throw new InsufficientBalanceException("Not enough balance.");



}

✅ Best Practice #7: Wrap Low-Level Exceptions for Higher Abstraction

try {

  connection.execute();



}
 catch (SQLException e) {

  throw new DataAccessException("Failed to fetch customer data", e);



}

🛡️ Tip: Always Log Exceptions Meaningfully

LOGGER.error("Customer fetch failed due to DB error", exception);

💡 Summary

• Be specific in catches
• Never ignore exceptions
• Use try-with-resources for clean code
• Never use exceptions for flow control
• Log all critical exceptions meaningfully

🧠 Section 13: Java I/O (File, Console, Buffered)

📘 Overview of Java I/O

Java I/O (Input/Output) is a core part of the Java Standard Library. It allows interaction with different data sources like files, consoles, memory buffers, and network sockets.

📂 I/O Categories:

• Byte Streams: Handles binary data using InputStream and OutputStream.
• Character Streams: Handles character data using Reader and Writer.

🔁 Buffered Streams:

• Improve performance by reducing the number of I/O calls.
• Examples: BufferedReader, BufferedWriter, BufferedInputStream.

💡 Why Use Buffered I/O?

• Reading line-by-line from a file or stream.
• Writing large text output efficiently.
• Reducing disk/network I/O operations.

📄 Example: Reading from Console using BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

System.out.print("Enter name: ");

String name = br.readLine();

System.out.println("Hello, " + name);

📄 Example: Writing to a File using BufferedWriter

BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));

writer.write("Hello World");

writer.newLine();

writer.write("Java I/O Example");

writer.close();

✅ BufferedWriter automatically flushes and buffers output to optimize writing large data sets.

📁 File I/O with FileReader and FileWriter

FileReader reader = new FileReader("input.txt");

int ch;

while ((ch = reader.read()) != -1) {

    System.out.print((char) ch);



}

reader.close();

🛠️ Tip:

Use try-with-resources to ensure files/streams close automatically:

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {

    // read logic


}

⚡ Part 2: FastReader Class for Competitive Programming

In Competitive Programming, speed matters. Standard input using Scanner is often too slow for large datasets. The solution? Use a custom FastReader class built with BufferedReader and StringTokenizer.

🚀 FastReader Template

static class FastReader {

    BufferedReader br;

    StringTokenizer st;


    public FastReader() {

        br = new BufferedReader(new InputStreamReader(System.in));

    

}


    String next() {

        while (st == null || !st.hasMoreElements()) {

            try {

                st = new StringTokenizer(br.readLine());

            

}
 catch (IOException e) {

                e.printStackTrace();

            

}

        

}

        return st.nextToken();

    

}


    int nextInt() {

        return Integer.parseInt(next());

    

}


    long nextLong() {

        return Long.parseLong(next());

    

}


    double nextDouble() {

        return Double.parseDouble(next());

    

}


    String nextLine() {

        String str = "";

        try {

            str = br.readLine();

        

}
 catch (IOException e) {

            e.printStackTrace();

        

}

        return str;

    

}



}

💡 Usage Example in CP:

FastReader fr = new FastReader();

int t = fr.nextInt();

while (t-- > 0) {

    int a = fr.nextInt();

    int b = fr.nextInt();

    System.out.println(a + b);



}

✅ Why Use FastReader?

• Extremely fast for reading millions of inputs
• Buffered I/O avoids costly character-by-character reads
• StringTokenizer skips parsing issues

📌 Tip:

Always use nextLine() carefully after nextInt() or next(), as it can cause input buffer issues.

📂 Part 2 Continued: Advanced I/O Techniques for File Projects

In Java-based projects, especially those dealing with large data, logs, or configurations, understanding efficient File I/O operations is essential. This includes using BufferedReader, BufferedWriter, and newer Files utility methods.

✍️ Writing to a File with BufferedWriter

try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {

    writer.write("Hello, Java File I/O!");

    writer.newLine();

    writer.write("Next line of text.");



}
 catch (IOException e) {

    e.printStackTrace();



}

📖 Reading from a File with BufferedReader

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {

    String line;

    while ((line = reader.readLine()) != null) {

        System.out.println(line);

    

}



}
 catch (IOException e) {

    e.printStackTrace();



}

📌 Tip:

BufferedWriter and BufferedReader reduce disk I/O calls by using a buffer, improving performance dramatically over FileWriter/FileReader directly.

📚 Java 7+ Files API (NIO)

Path path = Paths.get("input.txt");

List<String> lines = Files.readAllLines(path);

for (String line : lines) {

    System.out.println(line);



}


Files.write(Paths.get("log.txt"),
    Arrays.asList("First Line", "Second Line"),
    StandardCharsets.UTF_8,
    StandardOpenOption.CREATE,
    StandardOpenOption.APPEND);

✅ Why Use NIO Files API?

• More concise and readable
• Better exception handling
• Support for charset, file options, and atomic operations

🧪 Project Scenario:

Imagine building a log analyzer or a batch processor. Using BufferedReader with conditional filtering or counting helps efficiently process huge files with minimal memory impact.

Use try-with-resources for auto-closing streams and avoiding resource leaks.

🧵 Part 3: Summary of Best Practices + Performance Comparisons

✅ Best Practices for Java I/O

1. Always close streams using try-with-resources to avoid memory leaks.
2. Prefer BufferedReader/BufferedWriter over FileReader/FileWriter for efficiency.
3. For large file handling, process files line-by-line to reduce memory usage.
4. Use Files.readAllLines() only for small files where full content fits in memory.
5. Use appropriate Charsets (like UTF-8) to avoid encoding issues.
6. Leverage BufferedInputStream / BufferedOutputStream for binary data (images, files).
7. Log exceptions using logger frameworks instead of printStackTrace() in real projects.

📊 Performance Comparison (Speed & Memory)

📌 Final Takeaway:

Use buffered classes for performance, Scanner for input parsing, and Files API for simplicity and small files. Always consider encoding, memory footprint, and error handling for production-grade file I/O systems.

🧠 Section 14: Java Threads & Concurrency

🧠 Java Threads & Concurrency – Enhanced Deep Concepts (Part 1)

Java provides built-in support for multithreading, allowing programs to perform multiple tasks simultaneously. Each thread runs in its own call stack, managed by the JVM.

📌 What is a Thread?

A thread is a lightweight subprocess. Multiple threads within the same process share memory but have their own execution stacks.

🎯 Ways to Create Threads in Java

1. By Extending Thread class
2. By Implementing Runnable interface
3. Using ExecutorService (preferred in modern apps)

✔️ 1. Extending Thread

class MyThread extends Thread {

    public void run() {

        System.out.println("Thread is running...");

    

}



}


public class TestThread {

    public static void main(String[] args) {

        MyThread t1 = new MyThread();
  
        t1.start();
 // NEVER call run() directly
    

}



}

✔️ 2. Implementing Runnable

class MyRunnable implements Runnable {

    public void run() {

        System.out.println("Runnable thread running...");

    

}



}


public class TestRunnable {

    public static void main(String[] args) {

        Thread t = new Thread(new MyRunnable());

        t.start();

    

}



}

✔️ 3. Using ExecutorService

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;


public class ExecutorDemo {

    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.submit(() -> System.out.println("Task 1 executed"));

        executor.submit(() -> System.out.println("Task 2 executed"));

        executor.shutdown();

    

}



}

🌀 Thread Lifecycle

Java threads go through the following states:

• NEW – when thread object is created.
• RUNNABLE – after start() is called.
• RUNNING – actively executing.
• BLOCKED / WAITING / TIMED_WAITING – paused for lock/resource/timing.
• TERMINATED – after run() completes or error occurs.

Use Thread.State enum to check a thread’s status programmatically.

Thread t = new MyThread();

System.out.println(t.getState());
 // Output: NEW

🧠 Java Threads & Concurrency – Part 2: Synchronization Basics (to Advanced)

Multithreading enables concurrent execution, but when threads share resources (like variables, files, memory), data inconsistency can occur if access isn't controlled. This is where synchronization helps.

🔒 What is Synchronization?

Synchronization is the process of controlling access to shared resources by multiple threads. Java provides synchronized blocks/methods to ensure only one thread accesses critical sections at a time.

⚠️ Why Synchronization?

• To prevent race conditions
• To ensure atomicity of operations (especially on shared counters, objects)
• To maintain thread safety

✔️ Synchronizing a Method

class Counter {

    private int count = 0;


    public synchronized void increment() {

        count++;

    

}


    public int getCount() {

        return count;

    

}



}

This ensures only one thread executes increment() at a time.

✔️ Synchronizing a Block (More Fine-Grained)

class BankAccount {

    private int balance = 1000;


    public void deposit(int amount) {

        synchronized(this) {

            balance += amount;

        

}

    

}



}

You can also lock on custom objects instead of this:

private final Object lock = new Object();


public void criticalSection() {

    synchronized(lock) {

        // thread-safe operations
    

}



}

🔁 Reentrant Locks (Advanced)

Java provides ReentrantLock from java.util.concurrent.locks for more control over locking.

import java.util.concurrent.locks.ReentrantLock;


class Printer {

    private final ReentrantLock lock = new ReentrantLock();


    public void print() {

        lock.lock();

        try {

            System.out.println("Printing...");

        

}
 finally {

            lock.unlock();
 // Always unlock
        

}

    

}



}

🧩 Synchronized vs ReentrantLock

✅ Best Practices

• Lock only the necessary code (small critical section)
• Use final lock objects to avoid deadlocks
• Always release locks in a finally block
• Avoid nested synchronized blocks when possible

🧠 Java Threads & Concurrency – Part 3: Race Conditions, Synchronized Usage & Deadlocks

⚔️ What is a Race Condition?

A race condition occurs when multiple threads read and write shared data simultaneously, and the outcome depends on the thread scheduling order, often causing unexpected behavior.

🧪 Example (Without Synchronization)

class Counter implements Runnable {

    int count = 0;


    public void run() {

        for(int i = 0;
 i < 10000;
 i++) {

            count++;

        

}

    

}


    public static void main(String[] args) throws InterruptedException {

        Counter counter = new Counter();


        Thread t1 = new Thread(counter);

        Thread t2 = new Thread(counter);


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

        t1.join();
 t2.join();


        System.out.println("Final count: " + counter.count);
 // Not 20000!
    

}



}

✅ Fixing with Synchronized

synchronized(this) {

    count++;



}

✅ synchronized: Where & How to Use

• Use on methods when entire method is critical
• Use synchronized blocks when only part of method is critical
• Always lock on a final object or class

🔁 Static Synchronization

Locks on the Class object, not an instance.

public static synchronized void log(String msg) {

    System.out.println(msg);



}

🧨 Deadlocks

A deadlock happens when two or more threads wait indefinitely for each other to release a lock.

💣 Deadlock Example

class DeadlockDemo {

    static final Object lock1 = new Object();

    static final Object lock2 = new Object();


    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {

            synchronized(lock1) {

                System.out.println("T1 acquired lock1");

                try {
 Thread.sleep(100);
 

}
 catch (Exception e) {


}

                synchronized(lock2) {

                    System.out.println("T1 acquired lock2");

                

}

            

}

        

}
);


        Thread t2 = new Thread(() -> {

            synchronized(lock2) {

                System.out.println("T2 acquired lock2");

                try {
 Thread.sleep(100);
 

}
 catch (Exception e) {


}

                synchronized(lock1) {

                    System.out.println("T2 acquired lock1");

                

}

            

}

        

}
);


        t1.start();

        t2.start();

    

}



}

⚠️ Output:

T1 acquires lock1, T2 acquires lock2, and both wait forever – classic deadlock!

🛡️ Deadlock Prevention Techniques

• Lock ordering: Always acquire locks in a defined order
• Try-lock pattern: Use tryLock() with timeout (ReentrantLock)
• Avoid nested locking: Flatten logic if possible
• Thread dump analysis: Detect deadlocks with tools like jVisualVM, JConsole

✔️ Using tryLock

ReentrantLock lock1 = new ReentrantLock();

ReentrantLock lock2 = new ReentrantLock();


if (lock1.tryLock(1, TimeUnit.SECONDS)) {

    if (lock2.tryLock(1, TimeUnit.SECONDS)) {

        // Do work
        lock2.unlock();

    

}

    lock1.unlock();



}

🔄 Thread Safety

Thread-safe code ensures consistent results when accessed concurrently by multiple threads.

• Use Atomic classes: AtomicInteger, AtomicBoolean
• Use thread-safe collections: ConcurrentHashMap, CopyOnWriteArrayList
• Immutable objects: Cannot be modified once created, inherently thread-safe.

AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();

🎯 CP Tips & Patterns with Threads

While most competitive programming platforms (like Codeforces or AtCoder) run on a single thread, multithreading helps in:

• Optimizing large I/O or simulation-heavy tasks locally
• Modeling real-world concurrent problems (CP + System design contests)
• Parallel computation of prefix sums, segment calculations, matrix transforms, etc.

✅ Parallel Prefix Sum (Multithreaded)

Break an array into parts and compute prefix sum in parallel:

class PrefixWorker extends Thread {

  int[] arr, result;

  int start, end;


  PrefixWorker(int[] arr, int[] result, int start, int end) {

    this.arr = arr;

    this.result = result;

    this.start = start;

    this.end = end;

  

}


  public void run() {

    result[start] = arr[start];

    for (int i = start + 1;
 i <= end;
 i++) {

      result[i] = result[i - 1] + arr[i];

    

}

  

}



}

Useful when prefix computation is large and done on multicore CPUs.

🧮 Thread-safe Counters

In simulation or event-based CP problems, multiple agents (threads) updating shared counters:

import java.util.concurrent.atomic.AtomicInteger;


AtomicInteger sharedCounter = new AtomicInteger(0);


// Each thread safely increments
sharedCounter.incrementAndGet();

💡 Use case in CP simulation: Parallel BFS or Game Engine

// Simulate parallel BFS level processing (multithreaded expansion)
ExecutorService pool = Executors.newFixedThreadPool(4);

for (Node node : currentLevel) {

  pool.submit(() -> processNode(node));



}

pool.shutdown();

pool.awaitTermination(1, TimeUnit.MINUTES);

This is more for advanced algorithm visualizations or simulations during hackathons.

🛡 Thread-Safe DP Table

Sometimes, DP state transitions can be done in parallel (e.g., matrix-chain or convolution-style ops).

• Use row-wise locks or atomic updates
• Helps in reducing state update contention

🧪 Race Condition Testing in CP:

// Run code multiple times to stress-test for race conditions
for (int i = 0;
 i < 100000;
 i++) {

  // spawn threads, update shared state, assert correctness


}

🔥 Tip:

Java's ForkJoinPool or parallelStream() (Java 8) is great for parallel operations like mergesort, map-reduce, etc., in CP simulations.

List list = Arrays.asList(1, 2, 3, 4, 5);

int sum = list.parallelStream().reduce(0, Integer::sum);

📌 Final Note:

Use multithreading in CP **only when supported by the judge** or for local optimization/simulation. Always test determinism and avoid shared mutations unless safe.

class Outer {

    private String message = "Hello from Outer";


    class Inner {

        void show() {

            System.out.println("Inner accessing: " + message);

        

}

    

}


    void run() {

        Inner inner = new Inner();

        inner.show();

    

}



}


public class Test {

    public static void main(String[] args) {

        Outer outer = new Outer();

        outer.run();

    

}



}

class Container {

    static class StaticInner {

        void print() {

            System.out.println("Inside static nested class");

        

}

    

}


    void call() {

        StaticInner s = new StaticInner();

        s.print();

    

}



}

public class Greeting {

    void sayHello() {

        final String name = "Java";


        class LocalGreeter {

            void greet() {

                System.out.println("Hello, " + name);

            

}

        

}


        LocalGreeter greeter = new LocalGreeter();

        greeter.greet();

    

}


    public static void main(String[] args) {

        new Greeting().sayHello();

    

}



}

public class Task {

    public static void main(String[] args) {

        Runnable r = new Runnable() {

            public void run() {

                System.out.println("Running in an anonymous inner class.");

            

}

        

}
;

        new Thread(r).start();

    

}



}

(parameters) -> expression

(parameters) -> {

    // multiple lines


}

Runnable r = () -> System.out.println("Hello from Lambda!");

new Thread(r).start();

interface MathOp {

    int operate(int a, int b);



}


public class LambdaDemo {

    public static void main(String[] args) {

        MathOp add = (a, b) -> a + b;

        MathOp multiply = (a, b) -> a * b;


        System.out.println(add.operate(5, 3));
      // 8
        System.out.println(multiply.operate(5, 3));
 // 15
    

}



}

List<String> list = Arrays.asList("a", "b", "c");

list.forEach(s -> System.out.println(s.toUpperCase()));

Map<String, Integer> map = new HashMap<>();

map.put("apple", 3);

map.put("banana", 1);

map.put("orange", 2);


map.entrySet()
   .stream()
   .sorted((e1, e2) -> e1.getValue() - e2.getValue())
   .forEach(e -> System.out.println(e.getKey() + " -> " + e.getValue()));

🧠 Section 16: Enums, Constants & Immutability

📌 Why This Section Matters

This section is essential for writing clean, maintainable, and bug-free Java code. Understanding enums, constants, and immutability is crucial when designing:

• Domain models (e.g., LoanStatus.APPROVED)
• Concurrency-safe programs (e.g., final fields)
• Configurations, feature flags, and secure systems

🔢 Java Enums – Deep Concept

An enum in Java is a special type that defines a fixed set of constants. Unlike C/C++, Java enums are full-fledged classes that can have fields, methods, constructors, and interfaces.

// A simple enum
public enum LoanStatus {

    PENDING, APPROVED, REJECTED


}

Enums give us:

• Type safety: Only valid values can be used
• Better readability: Self-explanatory states
• Enum methods: You can add behavior per enum

// Enum with behavior
public enum LoanType {

    PERSONAL(12), HOME(8), CAR(9);


    private final int interestRate;


    LoanType(int rate) {

        this.interestRate = rate;

    

}


    public int getInterestRate() {

        return interestRate;

    

}



}

🔒 Immutability – Key to Thread Safety

An immutable object is one whose state cannot be changed after it’s created. Immutability is vital for:

• Preventing accidental data changes
• Safe multithreading
• Functional programming style

// Immutable class pattern
public final class User {

    private final String name;

    private final int age;


    public User(String name, int age) {

        this.name = name;

        this.age = age;

    

}


    public String getName() {
 return name;
 

}

    public int getAge() {
 return age;
 

}



}

Tip: Use final keyword on class fields, don’t expose setters, and return copies when needed.

📌 Constants with static final

public class Constants {

    public static final double PI = 3.14159;

    public static final String APP_NAME = "LoanManager";



}

These are class-level constants that are:

• static → shared across all objects
• final → value never changes
• public → accessible anywhere

Avoid using magic numbers in code – always replace with named constants.

🧩 Advanced Enum Strategies in Java

✅ Singleton Pattern using Enum

Enums are inherently thread-safe and support serialization, making them ideal for implementing the Singleton pattern.

// Singleton via enum
public enum ConfigManager {

    INSTANCE;


    private Map settings = new HashMap<>();


    public void put(String key, String value) {

        settings.put(key, value);

    

}


    public String get(String key) {

        return settings.get(key);

    

}



}

Use ConfigManager.INSTANCE.get("key") globally. It ensures:

• Thread-safe access
• No reflection breach
• No need for synchronized blocks

⚙️ Interface-Based Enum Strategy

Enums can implement interfaces, allowing for polymorphic behavior. It’s useful for replacing large switch-case logic.

// Strategy interface
public interface Operation {

    double apply(double x, double y);



}


// Enums as implementation
public enum BasicOperation implements Operation {

    ADD {

        public double apply(double x, double y) {
 return x + y;
 

}

    

}
,
    SUBTRACT {

        public double apply(double x, double y) {
 return x - y;
 

}

    

}
,
    MULTIPLY {

        public double apply(double x, double y) {
 return x * y;
 

}

    

}
,
    DIVIDE {

        public double apply(double x, double y) {
 return x / y;
 

}

    

}



}

Now you can write:

double result = BasicOperation.ADD.apply(10, 5);
 // 15.0

This improves:

• Readability
• Extensibility
• Testability (via mocking interfaces)

🔄 EnumSet & EnumMap

Specialized classes for enums offering better performance and clarity than traditional collections.

// Fast & compact set for enums
EnumSet statuses = EnumSet.of(LoanStatus.PENDING, LoanStatus.APPROVED);


// Optimized map for enums
EnumMap statusDescription = new EnumMap<>(LoanStatus.class);

statusDescription.put(LoanStatus.PENDING, "Waiting for review");

Why use them?

• Faster than HashMap for enum keys
• No null keys allowed (safe design)
• Backed by bit vectors internally

🔐 Immutability Patterns in Real-World Java Systems

✅ Why Immutability?

Immutability offers:

• Thread-safety without synchronization
• Better design clarity (fail-fast)
• Ease in debugging and unit testing
• Security - prevents object tampering

💡 Immutable DTO (Data Transfer Object)

Used in REST APIs, microservices, and event-driven architecture to prevent accidental state modification.

public final class UserDTO {

    private final String username;

    private final int age;


    public UserDTO(String username, int age) {

        this.username = username;

        this.age = age;

    

}


    public String getUsername() {

        return username;

    

}


    public int getAge() {

        return age;

    

}



}

Key traits: final class, final fields, no setters, no mutators.

🛡️ Immutable Config Object

Used for system-level constants or Spring Boot config bindings:

// Immutable config
@ConfigurationProperties(prefix = "app.security")
public final class SecurityProperties {

    private final String tokenSecret;

    private final int expirySeconds;


    public SecurityProperties(String tokenSecret, int expirySeconds) {

        this.tokenSecret = tokenSecret;

        this.expirySeconds = expirySeconds;

    

}


    public String getTokenSecret() {
 return tokenSecret;
 

}

    public int getExpirySeconds() {
 return expirySeconds;
 

}



}

This ensures externalized config cannot be modified at runtime.

🔒 Immutability for Security-Critical Domains

In areas like:

• Banking transactions
• User roles/permissions
• Digital signatures

Immutable objects ensure integrity and compliance. For example:

// Secure token model
public final class AuthToken {

    private final String token;

    private final Instant issuedAt;

    private final Instant expiresAt;


    public AuthToken(String token, Instant issuedAt, Instant expiresAt) {

        this.token = token;

        this.issuedAt = issuedAt;

        this.expiresAt = expiresAt;

    

}


    public String getToken() {
 return token;
 

}

    public Instant getIssuedAt() {
 return issuedAt;
 

}

    public Instant getExpiresAt() {
 return expiresAt;
 

}



}

This avoids issues like refresh-token tampering or stale data corruption.

📌 Bonus Tip: Use Lombok's @Value or Java 17+ record

// With Lombok
@Value
public class User {

    String name;

    int age;



}


// With Java 17
public record User(String name, int age) {


}

Both approaches offer concise syntax and enforce immutability automatically.

⚙️ Java Memory Management (Deep GC Tuning)

🔍 What is Java Memory Management?

Java memory management refers to how the Java Virtual Machine (JVM) allocates and deallocates memory on the heap and stack. The JVM handles most of the memory-related work using the Garbage Collector (GC), which reclaims memory used by unreachable objects.

📦 JVM Memory Areas

┌────────────────────────────┐
│        JVM Memory          │
├────────────────────────────┤
│ 📗 Heap                    │
│   ├─ Young Generation      │
│   │   ├─ Eden Space        │
│   │   ├─ Survivor Space S0 │
│   │   └─ Survivor Space S1 │
│   └─ Old Generation        │
│                            │
│ 📘 Non-Heap                │
│   ├─ Metaspace             │
│   ├─ Code Cache            │
│   └─ Interned Strings      │
└────────────────────────────┘

📈 Heap Memory – Key Concepts

• Young Gen: Stores newly created objects. Fast minor GC cycles.
• Old Gen (Tenured): Long-lived objects. Cleaned during major GC.
• Metaspace: Replaced PermGen in Java 8. Stores class metadata.

🚮 Garbage Collection Basics

GC is an automatic process that frees memory by deleting objects that are no longer reachable. Key GC types:

• Minor GC: Cleans Young Generation (Eden → Survivor)
• Major GC (Full GC): Cleans Old Generation + Young

🛠️ GC Algorithms Overview

📌 Example: GC Tuning for G1GC

java -XX:+UseG1GC \
     -Xms512m -Xmx2g \
     -XX:MaxGCPauseMillis=200 \
     -XX:+PrintGCDetails \
     -XX:+HeapDumpOnOutOfMemoryError

Explanation:

• -Xms/-Xmx: Set initial and max heap
• -XX:+UseG1GC: Use G1 Garbage Collector
• MaxGCPauseMillis: Targets pause time
• PrintGCDetails: Logs GC activity

🔄 Object Lifetime & Promotion

New objects are created in Eden. Surviving objects are moved (promoted) to Survivor spaces and eventually to Old Generation.

for (int i = 0;
 i < 10000;
 i++) {

    String s = new String("abc");
  // creates short-lived objects


}

Short-lived objects are quickly garbage collected. Use object pooling for long-lived instances.

⚠️ GC Tuning Mistakes

• Using large heap without increasing GC threads
• High allocation rate without tuning Young Gen
• Missing GC logs to diagnose pause time spikes

🧪 Tools for Analyzing GC

• VisualVM – Monitor heap, thread, GC
• JConsole – Real-time JVM stats
• JFR (Java Flight Recorder) – Profiler
• GC Log Analyzer – Tools like GCEasy.io

🧠 Real-World Tip

For microservices running on Kubernetes or Docker:

java -XX:+UseG1GC -XX:MaxRAMPercentage=80.0 -XX:+ExitOnOutOfMemoryError

This ensures your app exits on memory exhaustion cleanly and auto-restarts via container orchestrator.

📌 Summary of Best Practices

• Prefer G1GC for balanced performance (Java 11+)
• Tune -Xmx, -Xms, MaxGCPauseMillis
• Analyze GC logs with real traffic load
• For low-latency, explore ZGC or Shenandoah

🧠 JVM Internals & Performance Tuning – Part 1: Overview & Bytecode Lifecycle

1. Java Source to Bytecode to Machine

Java follows a multi-phase process to go from source code to executed machine instructions:

1. Java file compiled to .class bytecode using javac



2. Bytecode loaded into JVM via ClassLoader



3. Bytecode verified for safety



4. Executed by the Execution Engine (interpreter or JIT)

// File: HelloWorld.java
public class HelloWorld {

  public static void main(String[] args) {

    System.out.println("Hello, JVM!");

  

}



}


// Compiled using:
javac HelloWorld.java
// Generates HelloWorld.class (bytecode)

Why Important? Understanding this pipeline helps diagnose performance and class loading issues.

2. ClassLoader Hierarchy

The JVM uses a parent-delegation model to load classes:

• Bootstrap ClassLoader – Loads core Java classes from rt.jar



• Extension ClassLoader – Loads from ext/ directory



• Application ClassLoader – Loads from classpath

This ensures security and avoids class shadowing. You can write custom ClassLoaders for modularity or plugin loading.

// Check ClassLoader of a class
System.out.println(String.class.getClassLoader());
 // null → Bootstrap
System.out.println(MyClass.class.getClassLoader());
 // Application loader

3. Bytecode Verification

Before executing, the JVM verifies the bytecode to ensure it:

• Follows correct stack discipline



• Doesn't overflow memory or access invalid indexes



• Has valid method and field references

This is a key part of Java's sandboxing and prevents exploits from malformed .class files.

Best Practice: Avoid manually modifying bytecode unless you fully understand verification rules.

🧠 JVM Internals & Performance Tuning – Part 2: Execution Engine, JIT, and Optimization Layers

1. JVM Execution Engine

The Execution Engine is responsible for executing bytecode that has been loaded into memory. It contains:

• Interpreter – Reads and executes bytecode line-by-line. Used at first execution for faster startup.



• JIT Compiler (Just-In-Time) – Compiles hot (frequently executed) bytecode into native machine code for better performance.



• Garbage Collector – Automatically manages memory cleanup (we'll cover in a later part).

// Example: Hotspot optimizes frequent loops
for (int i = 0;
 i < 1000000;
 i++) {

  result += compute(i);
 // This block gets JIT-compiled


}

Why Important? JVM decides which parts of the code to optimize based on profiling. This means performance can improve the longer an app runs.

2. JIT Optimization Techniques

JVM applies advanced optimization techniques while JIT-compiling:

• Inlining – Replaces method calls with method body to avoid overhead.



• Loop Unrolling – Reduces iteration overhead for tight loops.



• Escape Analysis – Allocates objects on the stack instead of the heap if safe.



• Dead Code Elimination – Removes unused code blocks.

// Example of method that may be inlined
public int square(int x) {

  return x * x;



}

// Repeated calls to square() may be inlined
int result = square(5) + square(10);

Tip: Avoid overuse of small methods inside performance-critical loops. Let JVM inline where helpful.

3. Interpreter vs JIT: Trade-offs

Best Practice: Avoid benchmarking Java applications immediately after startup. Wait until JIT has optimized.

🧠 JVM Internals & Performance Tuning – Part 3: Garbage Collection and Heap Tuning

1. Java Garbage Collection (GC) Basics

Java automatically reclaims memory using Garbage Collection. Key generations in the heap:

• Young Generation – Stores short-lived objects. GC is fast and frequent here (Minor GC).



• Old Generation (Tenured) – Stores long-lived objects. GC is slower but less frequent (Major GC).



• Permanent Generation / Metaspace – Stores class metadata. (PermGen deprecated in Java 8, replaced by Metaspace.)

// Example GC-friendly pattern
for (int i = 0;
 i < 1_000_000;
 i++) {

    String data = new StringBuilder("ID:").append(i).toString();

    process(data);
 // short-lived object collected in Young Gen


}

Tip: Minimize long-lived object retention to reduce Major GC frequency.

2. Tuning the Heap Size

You can configure heap memory settings via JVM options:

-Xms512m               // Initial heap size
-Xmx2048m              // Maximum heap size
-Xmn512m               // Young generation size
-XX:PermSize=128m      // Initial PermGen (Java 7 and below)
-XX:MaxMetaspaceSize=256m // Java 8+

Best Practice: Set Xms and Xmx to same value in production to avoid resizing overhead.

3. GC Algorithms and Their Use Cases

• Serial GC – Best for small applications or single-core environments



• Parallel GC (Throughput) – Focuses on maximizing CPU utilization; default in many JVMs



• G1 GC (Garbage First) – Balances pause times and throughput; preferred for large heaps



• ZGC / Shenandoah – Ultra-low pause collectors; used for real-time, large memory systems

// Enable G1 GC
-XX:+UseG1GC

Note: G1 splits heap into regions instead of generations, allowing more predictable GC pauses.

🧠 JVM Internals & Performance Tuning – Part 4: Real-world Performance Optimization Patterns

1. Warm-Up before Benchmarking

The JVM uses Just-In-Time (JIT) compilation which means performance improves after the application runs for a while.

// Bad: Benchmark too early
public static void main(String[] args) {

    long start = System.nanoTime();

    runAlgo();
 // might be interpreted
    long end = System.nanoTime();

    System.out.println("Time = " + (end - start));



}


// Good: Warm-up phase
for (int i = 0;
 i < 1000;
 i++) runAlgo();
 // warm-up
long start = System.nanoTime();

runAlgo();
 // now JIT optimized
long end = System.nanoTime();

System.out.println("Time = " + (end - start));

Tip: Use warm-up loops to ensure JIT kicks in before measuring performance.

2. Object Reuse and Caching

Creating too many temporary objects leads to GC pressure. Prefer object reuse and object pooling where possible.

// Instead of creating new object every time
StringBuilder sb = new StringBuilder();

for (int i = 0;
 i < N;
 i++) {

    sb.setLength(0);
 // reset buffer
    sb.append("Prefix").append(i);

    process(sb.toString());



}

Why? Reduces heap churn and unnecessary GC cycles. Object pooling is vital for high-throughput systems (e.g., Netty, DB pools).

3. Use Immutable Structures for Multi-threaded Safety

Mutable structures increase synchronization cost. Immutables are GC-friendly and thread-safe by design.

final class Config {

    private final int maxThreads;

    private final String host;

    public Config(int maxThreads, String host) {

        this.maxThreads = maxThreads;

        this.host = host;

    

}

    public int getMaxThreads() {
 return maxThreads;
 

}

    public String getHost() {
 return host;
 

}



}

Bonus: JVM can optimize access to immutable fields via CPU-level caching.

4. Tune GC Based on Application Nature

• Short-lived bursty tasks? ➜ Use G1 GC for predictable latency.



• CPU-intensive batch jobs? ➜ Parallel GC for throughput.



• Large, real-time systems? ➜ Try ZGC/Shenandoah for sub-10ms pauses.

// Sample tuning for a bursty web server
-XX:+UseG1GC -XX:MaxGCPauseMillis=100 -Xms512m -Xmx2g

Real-world Insight: GC tuning should match SLA requirements (latency vs. throughput).

5. Use Profilers & JVM Monitoring Tools

Don’t guess — measure! Use tools like:

• VisualVM – heap dumps, GC stats, thread inspection



• JFR (Java Flight Recorder) – detailed profiling with low overhead



• jstat, jstack, jmap – CLI tools for live monitoring



• Async Profiler – flame graphs for hotspot detection

Tip: Run your app under load and inspect CPU, memory, and GC pause metrics for bottlenecks.

✅ Summary

• Warm up before benchmarking to allow JIT to optimize



• Reuse objects and avoid unnecessary allocation



• Immutability helps with GC and thread-safety



• Tune GC according to the system's SLA: latency or throughput



• Use profiling tools to identify and fix real issues

✅ Java Reflection API – Part 1: Deep Concepts & Basics

1. What is Reflection?

Reflection is a powerful feature in Java that allows programs to inspect and manipulate classes, methods, fields, and constructors at runtime — even if they are private.

Class<?> cls = Class.forName("java.util.ArrayList");

Method[] methods = cls.getDeclaredMethods();

for (Method method : methods) {

    System.out.println(method.getName());



}

Why? Enables dynamic behavior in frameworks like Spring, Hibernate, JUnit, and serialization libraries.

2. Accessing Class Info Dynamically

You can get class metadata using `Class` object:

public class Student {

    private int id;

    public String name;


    public void sayHello() {

        System.out.println("Hi!");

    

}



}


// Accessing metadata
Class<?> cls = Student.class;

System.out.println(cls.getName());
 // Student
System.out.println(cls.getDeclaredFields().length);
 // 2

3. Accessing Private Fields and Methods

Reflection allows accessing private members using `setAccessible(true)`:

Field field = Student.class.getDeclaredField("id");

field.setAccessible(true);

Student obj = new Student();

field.set(obj, 101);
 // setting private field
System.out.println(field.get(obj));
 // 101

Security Note: Java 9+ restricts deep reflection without proper module access (JVM warning or failure).

4. Dynamic Method Invocation

Method method = Student.class.getDeclaredMethod("sayHello");

method.invoke(new Student());
 // prints: Hi!

Use Case: Useful in plugin architectures, dependency injection, or testing frameworks.

5. Dynamic Object Creation

Constructor<?> constructor = Student.class.getConstructor();

Student student = (Student) constructor.newInstance();

Advanced: You can also dynamically choose constructors based on parameters or annotations.

Advanced: Dynamic Constructor Selection

You can dynamically choose and invoke constructors based on parameter types or annotations. This is powerful for framework-level object creation or plugin loaders.

// Class with multiple constructors
public class Person {

    public Person() {


}

    public Person(String name) {


}

    public Person(String name, int age) {


}



}


// Dynamically pick constructor based on params
Constructor<?> constructor = Person.class.getConstructor(String.class, int.class);

Person person = (Person) constructor.newInstance("Alice", 25);

Use Case: Dependency injection containers and serialization libraries use this pattern to create objects dynamically with context-aware logic.

✅ Summary

• Reflection allows runtime inspection and manipulation of classes



• Supports private member access via `setAccessible(true)`



• Used in frameworks like Spring, Hibernate, JUnit, Gson, etc.



• Enables dynamic method calls and instance creation

✅ Java Reflection API – Part 2: Annotations, Performance, and Best Practices

6. Reading Annotations via Reflection

Reflection lets you read annotations at runtime, enabling frameworks to apply behaviors based on metadata.

@Deprecated
public void oldMethod() {


}


Method method = MyClass.class.getDeclaredMethod("oldMethod");

if (method.isAnnotationPresent(Deprecated.class)) {

    System.out.println("This method is deprecated.");



}

Use Case: This is how Spring and JUnit detect `@Autowired`, `@Test`, etc.

7. Performance Overhead of Reflection

• Slower Execution: Reflection bypasses normal optimizations like inlining and caching.



• Security Risks: Exposes internals, which can be abused if access is not controlled.



• Memory Overhead: Repeated reflective operations increase GC pressure.

Tip: Avoid reflection in performance-critical paths. Use it only for configuration or setup stages.

8. Framework Internals That Use Reflection

• Spring: Uses reflection to inject dependencies (`@Autowired`), scan beans, and create proxies.



• JUnit: Invokes test methods dynamically using reflection.



• Jackson / Gson: Deserialize/serialize Java objects to/from JSON by accessing fields dynamically.



• Hibernate: Maps class fields to DB columns via annotations and reflection.

// Example: Spring injecting bean
@Autowired
private UserService userService;

Behind the Scenes: Spring scans classes, checks annotations, and injects objects via reflection.

9. Best Practices for Using Reflection

• Avoid overuse: Use only when static coding isn’t feasible (e.g., plugin discovery).



• Use caching: Cache reflective objects like `Method` or `Field` if used repeatedly.



• Respect encapsulation: Prefer `public` members where possible to avoid `setAccessible` risks.



• Fail early: Wrap reflection calls with proper exception handling.

// Cache and reuse Method object
Method sayHi = Student.class.getMethod("sayHello");

for (int i = 0;
 i < 1000;
 i++) {

    sayHi.invoke(student);
 // reusing Method reference


}

✅ Reflection Summary

• ✅ Enables dynamic inspection and manipulation at runtime.



• ✅ Critical for framework design, plugin loading, testing, and ORM tools.



• ✅ Must be used with caution due to performance and security trade-offs.

🔖 Java Annotations – Part 1: Fundamentals & Built-in Annotations

1. What Are Annotations in Java?

Annotations are metadata added to Java code that do not affect the execution directly but provide information to the compiler, IDEs, or frameworks for processing logic.

// Example
@Override
public String toString() {

    return "Hello";



}

Use Cases: Code generation, compile-time checks, runtime behavior modification (via Reflection), and framework configurations (Spring, JUnit).

2. Common Built-in Annotations

• @Override – Ensures you're overriding a method from a superclass or interface.



• @Deprecated – Marks a method/class as outdated or discouraged for use.



• @SuppressWarnings – Prevents specific compiler warnings.



• @FunctionalInterface – Ensures the interface has only one abstract method (Java 8+).



• @SafeVarargs – Suppresses heap pollution warnings for varargs.

// Example
@Deprecated
public void oldMethod() {

    // Do something


}

Tip: Use annotations to write safer, more expressive, and tool-friendly code.

🔖 Java Annotations – Part 2: Targets, Retention Policies & Meta-Annotations

1. @Target – Where Can the Annotation Be Applied?

The @Target meta-annotation specifies where your custom annotation can be used — on methods, fields, parameters, constructors, classes, etc.

import java.lang.annotation.ElementType;

import java.lang.annotation.Target;


@Target({
ElementType.METHOD, ElementType.FIELD

}
)
public @interface MyAnnotation {


}

ElementType options:

• TYPE – Class, interface, enum



• METHOD – Methods



• FIELD – Variables and fields



• CONSTRUCTOR, PARAMETER, LOCAL_VARIABLE, etc.

Why Important? Prevents accidental misuse of your annotation.

2. @Retention – When Is the Annotation Available?

The @Retention meta-annotation controls how long the annotation is retained:

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;


@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {


}

• SOURCE – Discarded by the compiler (not in .class)



• CLASS – Stored in the .class file but not available at runtime (default)



• RUNTIME – Available during execution via Reflection (used in Spring, JUnit, etc.)

Tip: Use RUNTIME for annotations processed during execution.

3. Other Meta-Annotations

• @Documented – Makes your annotation appear in Javadoc.



• @Inherited – Allows subclass to inherit superclass annotations.



• @Repeatable – Enables multiple annotations of the same type on one element (Java 8+).

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Auditable {


}

Example: Using @Repeatable

@Roles({
@Role("ADMIN"), @Role("USER")

}
)
public class AdminPanel {


}


@Repeatable(Roles.class)
public @interface Role {

    String value();



}


public @interface Roles {

    Role[] value();



}

Use Case: Useful in access control, tagging strategies, or logging annotations.

🔖 Java Annotations – Part 3: Creating and Using Custom Annotations in Real Projects

1. Creating a Basic Custom Annotation

You can define your own annotation using @interface. For example, a simple annotation for logging method execution:

import java.lang.annotation.*;


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {


}

Usage:

public class MyService {


    @LogExecutionTime
    public void perform() {

        // method logic
    

}



}

Note: This annotation alone does nothing unless processed using Reflection or Aspect-Oriented Programming (AOP).

2. Processing Custom Annotations with Reflection

You can use Reflection to read and react to annotations at runtime:

import java.lang.reflect.Method;


public class AnnotationProcessor {

    public static void process(Object obj) throws Exception {

        for (Method method : obj.getClass().getDeclaredMethods()) {

            if (method.isAnnotationPresent(LogExecutionTime.class)) {

                long start = System.nanoTime();

                method.invoke(obj);

                long end = System.nanoTime();

                System.out.println(method.getName() + " took " + (end - start) + " ns");

            

}

        

}

    

}



}

Use Case: Monitoring performance, logging behavior, auditing actions.

3. Annotations with Parameters

You can define annotations with default or required parameters:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {

    String name();

    boolean unique() default false;



}

Usage:

public class User {

    @Column(name = "user_id", unique = true)
    private String id;



}

Why? Great for ORM-style mapping (like JPA), validation, or dynamic config.

4. Real-world Example: @JsonProperty

Used in Jackson library to map JSON keys to Java fields:

public class Employee {

    @JsonProperty("employee_id")
    private String id;



}

Framework Integration: Most frameworks (Spring, Hibernate, Jackson) use custom annotations internally for declarative configuration.

Best Practice: Keep annotations lightweight. Do not overload them with business logic—just metadata!

🔖 Java Annotations – Part 4: Annotation Processing at Compile-Time (APT, Annotation Processors, Lombok)

1. What Is Annotation Processing?

Annotation Processing allows tools to read your annotations during the compilation phase and generate code or perform validation. This is done using the Java APT (Annotation Processing Tool) or modern javax.annotation.processing APIs.

// Use case: Auto-generating Builder, toString(), equals() methods
// Frameworks like Lombok, Dagger, MapStruct rely on this.

Why? Reduces boilerplate code and automates compile-time checks.

2. Creating a Compile-Time Annotation Processor

Steps to build your own annotation processor:

1. Create a class that extends AbstractProcessor
2. Override process() method
3. Use RoundEnvironment to iterate over annotated elements
4. Register processor in META-INF/services

public class MyProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {

        for (Element element : env.getElementsAnnotatedWith(MyAnnotation.class)) {

            // Generate code, validate, or log
        

}

        return true;

    

}



}

Register: Add to META-INF/services/javax.annotation.processing.Processor:

com.example.MyProcessor

3. Using Lombok (Compile-time Code Generation)

Lombok is a popular library that uses compile-time annotation processing to eliminate boilerplate code:

import lombok.*;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;

    private int age;



}

Features:

• @Getter, @Setter, @ToString – Auto-generates methods
• @Builder – Creates builder pattern
• @Value – Creates immutable objects

Tip: Lombok requires annotation processing to be enabled in IDEs like IntelliJ or Eclipse.

4. Annotation Processors in Frameworks

Popular frameworks use compile-time annotation processing:

• Dagger – Dependency injection at compile time
• MapStruct – Auto-generates mapper classes between DTOs and entities
• Room (Android) – Generates SQLite access code

Benefit: Avoids runtime reflection overhead and improves startup time.

5. Best Practices

• Use compile-time processing when performance or static checks are critical.
• For framework creation, prefer APT over reflection where possible.
• Keep annotation processors modular and avoid I/O during processing.

Want to go deeper? You can also explore javapoet for generating source code from annotation processors.

🔖 Java Annotations – Part 5: Combining Annotations with Reflection for Dynamic Behavior

1. Why Combine Annotations with Reflection?

Annotations alone are passive metadata. But when paired with Reflection, we can dynamically read and respond to annotations at runtime, enabling features like:

• Custom dependency injection
• Dynamic validation frameworks
• Auto-wiring, routing, ORM mappings

2. Reading Annotations at Runtime

Use the java.lang.reflect API to access class/method/field-level annotations and act accordingly.

// Example: Custom @Log annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Log {


}


class MyService {

    @Log
    public void doWork() {
 System.out.println("Work Done!");
 

}



}


// Reflective handler
for (Method m : MyService.class.getDeclaredMethods()) {

    if (m.isAnnotationPresent(Log.class)) {

        System.out.println("Logging method: " + m.getName());

        m.invoke(new MyService());
 // Invoke dynamically
    

}



}

Why Useful? This technique enables AOP (Aspect-Oriented Programming) like behavior without external tools.

3. Validation Example Using Annotations

// Define annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface NotNull {


}


// Apply to a class
class User {

    @NotNull
    String name;


    int age;



}


// Reflectively validate object
User user = new User();
 // name is null
for (Field f : User.class.getDeclaredFields()) {

    f.setAccessible(true);

    if (f.isAnnotationPresent(NotNull.class) && f.get(user) == null) {

        throw new RuntimeException(f.getName() + " must not be null!");

    

}



}

Real Use: This concept is used in frameworks like Hibernate Validator and Bean Validation API.

4. Dynamic Routing with Custom @Endpoint

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Endpoint {

    String path();



}


class Router {

    @Endpoint(path="/home")
    public void home() {
 System.out.println("Welcome!");
 

}



}


// Simulate router handler
String reqPath = "/home";

for (Method m : Router.class.getDeclaredMethods()) {

    Endpoint ep = m.getAnnotation(Endpoint.class);

    if (ep != null && ep.path().equals(reqPath)) {

        m.invoke(new Router());

    

}



}

Used In: REST frameworks like Spring use similar techniques with @GetMapping, @PostMapping.

5. Combine with Security or Config

Use annotations to add metadata for security roles, configurations, or permissions:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Secured {

    String role();



}

Then validate before invoking methods using reflection based on the current user's role.

✅ Summary

• Annotations + Reflection = Dynamic and metadata-driven behavior
• Enables building lightweight frameworks and custom processors
• Powerful for runtime routing, validation, DI, and more

🔖 Java Annotations – Part 6: Annotation Inheritance & Repeatable Annotations

1. Annotation Inheritance with @Inherited

By default, annotations are not inherited by subclasses. To make an annotation automatically apply to a subclass, mark it with @Inherited.

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface MyAnnotation {


}


@MyAnnotation
class Parent {


}


class Child extends Parent {


}

// Checking annotation at runtime:
System.out.println(Child.class.isAnnotationPresent(MyAnnotation.class));
 // true

Important: @Inherited only works for class-level annotations. It doesn’t apply to methods or fields.

2. Repeatable Annotations (Java 8+)

Before Java 8, applying the same annotation multiple times on a single element wasn’t allowed. With @Repeatable, now it is!

Example: Define a custom repeatable annotation.

@Repeatable(Hints.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Hint {

    String value();



}


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Hints {

    Hint[] value();



}

Now we can use @Hint multiple times:

@Hint("Optimize")
@Hint("Secure")
class Task {


}

And reflectively access them:

Hint[] hints = Task.class.getAnnotationsByType(Hint.class);

for (Hint h : hints) {

    System.out.println(h.value());



}

Real-world Use: Common in testing annotations like @Tag in JUnit 5, and Spring’s @AliasFor scenarios.

✅ Summary

• @Inherited allows class-level annotations to be passed to subclasses
• @Repeatable enables multiple annotations of the same type
• Helps build flexible annotation models for config, tagging, and roles

🔖 Java Annotations – Part 7: Real-World Usage in JUnit, Spring Boot, and Mocking

1. JUnit Annotations – Unit Testing Power

JUnit 5 introduced many annotations to define test lifecycle, expected outcomes, and behavior. Some key annotations:

• @Test – Marks a method as a test method.



• @BeforeEach / @AfterEach – Runs before/after each test.



• @BeforeAll / @AfterAll – Runs once before/after all tests.



• @DisplayName – Provides custom test name in reports.



• @Disabled – Skips the test.



• @Tag – Used for grouping tests.

class MathTest {

    @BeforeEach
    void setup() {

        System.out.println("Setup!");

    

}


    @Test
    @DisplayName("Simple Addition Test")
    void testAdd() {

        assertEquals(2, 1 + 1);

    

}



}

Tip: Use @Nested to group related tests.

2. Spring Boot Testing Annotations

Spring uses annotations heavily to configure test contexts and inject mocks:

• @SpringBootTest – Boots full Spring context for integration testing.



• @DataJpaTest – For testing JPA repositories (starts DB layer only).



• @WebMvcTest – For controller layer tests without starting full app.



• @MockBean – Replaces real bean with mock in context.



• @Autowired – Injects test subject.

@SpringBootTest
class UserServiceTest {


    @MockBean
    private UserRepository userRepository;


    @Autowired
    private UserService userService;


    @Test
    void testFindUser() {

        when(userRepository.findById(1L)).thenReturn(Optional.of(new User(1L, "John")));

        assertEquals("John", userService.getName(1L));

    

}



}

Note: Avoid @SpringBootTest if a lightweight test (e.g., @WebMvcTest) suffices to improve speed.

3. Mocking Annotations (Mockito)

Mockito is a popular mocking framework that also leverages annotations:

• @Mock – Creates a mock object.



• @InjectMocks – Injects mocks into the test subject.



• @Captor – Allows capturing arguments passed to methods.



• @Spy – Partial mocking; calls real methods unless stubbed.

@ExtendWith(MockitoExtension.class)
class LoginServiceTest {


    @Mock
    private UserRepository userRepository;


    @InjectMocks
    private LoginService loginService;


    @Test
    void testLogin() {

        when(userRepository.exists("admin")).thenReturn(true);

        assertTrue(loginService.login("admin"));

    

}



}

Real-World Insight: Mockito + Spring + JUnit annotations enable powerful isolated and integrated test combinations with minimal config.

✅ Summary

• JUnit annotations define lifecycle, grouping, and behaviors of test methods.
• Spring testing annotations configure dependency injection and test contexts.
• Mockito annotations simplify mocking, spying, and argument capture in unit tests.

🔖 Java Annotations – Part 8: Meta-Annotation Composition Techniques

1. What Are Meta-Annotations?

Meta-annotations are annotations that apply to other annotation definitions. They define how custom annotations behave — especially for processing tools, frameworks, and reflection logic.

Common meta-annotations include:

• @Target – Specifies where the annotation can be applied (methods, fields, classes, etc.)



• @Retention – Controls how long the annotation is retained (source, class, runtime)



• @Inherited – Allows subclass to inherit annotation from its superclass



• @Documented – Includes the annotation in the generated JavaDocs



• @Repeatable – Allows multiple instances of the annotation on the same element (Java 8+)

// Meta-annotation usage
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Audit {

  String action();



}

Tip: Meta-annotations are necessary when building any reusable annotation in a library or framework.

2. Composing Annotations with Other Annotations (Spring Style)

Frameworks like Spring allow combining multiple annotations into one "composed" annotation:

// Composed annotation
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {



}

Why? It makes code more readable and encapsulates intent better.

// Instead of:
@Controller
@ResponseBody
class UserApi {
 ... 

}


// You can write:
@RestController
class UserApi {
 ... 

}

Real World: This approach is widely used in Spring Boot, Micronaut, Quarkus, etc.

3. Use Case – Custom Security Annotation Composition

Suppose you want to apply role-based access and logging together — create a composed annotation:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Audit(action = "ACCESS")
@PreAuthorize("hasRole('ADMIN')")
public @interface AdminAction {



}

Advantage: Instead of duplicating annotations for access control, you use a single reusable tag everywhere.

4. Annotation Aliasing with @AliasFor (Spring Specific)

Spring supports aliasing values in composed annotations using @AliasFor:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface CustomService {


  @AliasFor(annotation = Component.class, attribute = "value")
  String name() default "";



}

Now you can write:

@CustomService(name = "orderService")

Why Useful? You provide a clean abstraction while maintaining link to base annotation.

✅ Summary

• Meta-annotations control where/how annotations are processed.
• Composed annotations help simplify and organize repeated annotation use.
• Spring’s @AliasFor adds power to link attributes in composed annotations.

📦 Java Generics – Part 1: Basics & Type Safety

1. Why Generics?

Java Generics enable classes, interfaces, and methods to operate on typed parameters. This improves type safety, reusability, and readability without sacrificing performance.

// Without Generics (Type casting required)
List list = new ArrayList();

list.add("Hello");

String s = (String) list.get(0);
 // Unsafe, may cause ClassCastException

// With Generics
List<String> list = new ArrayList<>();

list.add("Hello");

String s = list.get(0);
 // Safe, no casting needed

Why Important? Generics eliminate runtime type errors and make code more expressive by enforcing compile-time checks.

2. Generic Class Syntax

A class can define a generic type parameter using angle brackets (<>).

class Box<T> {

  private T value;


  public void set(T value) {

    this.value = value;

  

}


  public T get() {

    return value;

  

}



}

Box<String> strBox = new Box<>();

strBox.set("Hello");

System.out.println(strBox.get());
 // Output: Hello

Note: Type erasure removes generic type info at runtime, so generics only affect compile-time behavior.

📦 Java Generics – Part 2: Bounded Type Parameters & Wildcards

1. Bounded Type Parameters

Bounded types restrict the kinds of types that can be used as generic parameters using extends or super.

// T must be a subclass of Number
class Calculator<T extends Number> {

  public double add(T a, T b) {

    return a.doubleValue() + b.doubleValue();

  

}



}

Why? To ensure the generic type supports certain operations or methods (e.g., doubleValue()).

Calculator<Integer> intCalc = new Calculator<>();

System.out.println(intCalc.add(10, 20));
 // Output: 30.0

Tip: You can bound a generic type to multiple interfaces using <T extends Interface1 & Interface2>.

2. Wildcards (?)

Wildcards provide flexibility in method arguments when the exact type parameter is unknown.

? extends T (Upper Bounded Wildcard)

Used when you want to read from a structure but not write into it (producer role).

public void printNumbers(List<? extends Number> list) {

  for (Number num : list) {

    System.out.println(num);

  

}



}

? super T (Lower Bounded Wildcard)

Used when you want to write into a structure but not read from it (consumer role).

public void addIntegers(List<? super Integer> list) {

  list.add(1);

  list.add(2);



}

Tip: Use PECS rule: Producer extends, Consumer super.

3. Unbounded Wildcard: ?

Use when you want to accept any type but don’t care what it is:

public void printList(List<?> list) {

  for (Object obj : list) {

    System.out.println(obj);

  

}



}

Note: You can’t add elements to List<?> except null due to type safety.

4. Common Mistakes to Avoid

• Using ? extends T and trying to insert values → ❌ Compiler Error



• Using ? super T but assuming return types are T → ❌ Need casting

// Will cause error
void add(List<? extends Number> list) {

  list.add(10);
 // ❌ Not allowed


}

Best Practice: Use bounded wildcards in method arguments, not in class-level declarations.

📦 Java Generics – Part 3: Generic Methods & Constructors

1. Generic Methods

You can define methods with their own generic type parameters, even if the class itself is not generic.

public class Utility {
 // Generic method with type T public static <T> void printArray(T[] array) {
 for (T item : array) {
 System.out.println(item);
 

}
 

}
 

}
 

String[] names = {
"Alice", "Bob"

}
;
 Integer[] nums = {
1, 2, 3

}
;
 Utility.printArray(names);
 Utility.printArray(nums);
 

Why Useful? Generic methods allow reusability without requiring the whole class to be generic.

2. Generic Constructors

Constructors can also have their own type parameters independent of the class’s type.

class Printer {
 <T> Printer(T item) {
 System.out.println("Printing: " + item);
 

}
 

}
 new Printer("Hello");
 new Printer(123);
 

Note: Even if the class itself isn’t generic, the constructor can accept any type via a type parameter.

3. Generic Method with Bounded Types

// Accepts only Number or its subclasses public static <T extends Number> double sum(T a, T b) {
 return a.doubleValue() + b.doubleValue();
 

}
 

System.out.println(sum(10, 20));
 // 30.0 System.out.println(sum(3.5, 2.5));
 // 6.0 

Best Practice: Use generic methods when the logic depends only on parameter types, not class structure.

📦 Java Generics – Part 4: Type Erasure, Bridge Methods & Reflection

1. Type Erasure in Java

Java uses Type Erasure to implement generics. At compile time, generic type parameters are removed and replaced with their bounds (or Object if unbounded).

// Generic List<String> list = new ArrayList<>();
 list.add("hello");
 // After type erasure (conceptual) List list = new ArrayList();
 list.add("hello");
 

Impact: At runtime, generic type information is not available. You can’t use instanceof or reflection to check actual generic types.

// Compile-time error if (list instanceof List<String>) {
 

}
 // ❌ if (list instanceof List) {
 

}
 // ✅

2. Bridge Methods

Bridge methods are synthetic methods generated by the compiler to maintain polymorphism after type erasure.

// Generic superclass class GenericBox<T> {
 public T get() {
 return null;
 

}
 

}
 // Subclass with concrete type class StringBox extends GenericBox<String> {
 public String get() {
 return "data";
 

}
 

}
 

⚙️ After erasure, method signatures may conflict. The compiler generates a bridge method to ensure polymorphism:

// Bridge method generated public Object get() {
 return get();
 // calls actual get() returning String 

}
 

Note: You typically don’t see these, but tools like javap or debugging may show them.

3. Reflection with Generics

You can inspect generic type declarations with java.lang.reflect API, but only the raw type is available at runtime unless explicitly preserved.

import java.lang.reflect.*;
 class MyClass<T> {
 

}
 public static void main(String[] args) {
 MyClass<String> obj = new MyClass<>();
 System.out.println(obj.getClass());
 // class MyClass 

}
 

⚠️ This only gives the raw class, not the generic type <String>.

// Workaround using reflection on fields or superclass Field field = SomeClass.class.getDeclaredField("myList");
 Type type = field.getGenericType();

Important: Frameworks like Spring and Jackson use advanced tricks (e.g., subclassing, annotations) to retain and use generic type information at runtime.

📦 Java Generics – Part 5: Wildcards (? extends, ? super) and the PECS Principle

1. What Are Wildcards in Generics?

Wildcards in Java Generics represent unknown types. They're used when the exact type parameter is not known at compile time but flexibility is needed for subtyping.

List<?> list = new ArrayList<String>();
 // ? means unknown type 

Why Use? To allow code reuse and flexibility while preserving type safety.

2. ? extends T – Upper Bounded Wildcards

Allows a structure to accept any subtype of T. Used when the code only needs to read data from the structure.

public void printNumbers(List<? extends Number> list) {
 for (Number n : list) {
 System.out.println(n);
 

}
 

}
 

Note: You cannot add to such a list (except `null`) because the exact subtype is unknown.

list.add(10);
 // ❌ Compiler error list.add(null);
 // ✅ Allowed 

3. ? super T – Lower Bounded Wildcards

Allows a structure to accept T or any supertype of T. Useful when you want to write to the structure.

public void addIntegers(List<? super Integer> list) {
 list.add(1);
 list.add(2);
 

}
 

Note: Reading from such a list returns `Object`, because the compiler doesn't know the exact supertype.

4. PECS Principle (Producer Extends, Consumer Super)

Remember this rule when deciding between `? extends` and `? super`:

• Producer → ? extends T → You only read from the collection.



• Consumer → ? super T → You only write to the collection.

// Example: Copying data from producer to consumer public static <T> void copy(List<? extends T> src, List<? super T> dest) {
 for (T item : src) {
 dest.add(item);
 

}
 

}
 

Why PECS? It helps you design APIs that are both flexible and type-safe when reading from or writing to generic containers.

📦 Java Generics – Part 6: Bounded Type Parameters with Multiple Constraints

1. Single Bound Syntax

When a generic type is restricted to a specific superclass or interface, it’s called a bounded type parameter. The basic syntax uses the `extends` keyword:

// T must be a subclass of Number class Calculator<T extends Number> {
 T value;
 

}
 

Note: You can only use one class as a bound, but you can add multiple interfaces.

2. Multiple Bounds with Interfaces

To specify multiple constraints, Java allows you to define one class (first) and then one or more interfaces:

// T must be a subclass of Number AND implement Comparable & Serializable class GenericProcessor<T extends Number & Comparable<T> & Serializable> {
 T value;
 public void process() {
 System.out.println("Processing: " + value);
 

}
 

}
 

Rules:

• Only one class can be used, and it must appear first.



• You can specify multiple interfaces.

3. Why Use Multiple Bounds?

To write powerful, reusable components that depend on multiple behaviors:

• Class constraint → Inherit core structure (e.g., `Number`, `Shape`).



• Interface constraints → Require behavioral contracts (e.g., `Comparable`, `Closeable`).

// A reusable sorting wrapper class BoundedSorter<T extends Comparable<T> & Serializable> {
 public void sort(List<T> list) {
 Collections.sort(list);
 // Requires Comparable 

}
 

}
 

4. Best Practices

• Use multiple bounds to enforce method contracts during compile-time.



• Helps build type-safe utilities (sorters, serializers, formatters).



• Document bounds clearly for better API readability.

📦 Java Generics – Part 7: Real-World Generic Patterns (DAOs, Services, Builders)

1. Generic DAO Pattern

Data Access Objects (DAOs) are commonly designed using generics to support CRUD operations on any entity type.

// Generic DAO interface public interface GenericDao<T, ID> {
 T findById(ID id);
 List<T> findAll();
 void save(T entity);
 void delete(ID id);
 

}
 

// Concrete DAO implementation public class UserDao implements GenericDao<User, Integer> {
 public User findById(Integer id) {
 /* ... */ 

}
 public List<User> findAll() {
 /* ... */ 

}
 public void save(User user) {
 /* ... */ 

}
 public void delete(Integer id) {
 /* ... */ 

}
 

}
 

Why Use? Reduces code duplication across DAO layers and enables type-safe operations for all entities.

2. Generic Service Layer

Service classes that operate on multiple entity types benefit from generics by centralizing business logic.

// Generic service public class GenericService<T> {
 private List<T> cache = new ArrayList<>();
 public void add(T item) {
 cache.add(item);
 

}
 public T get(int index) {
 return cache.get(index);
 

}
 

}
 

// Usage GenericService<Product> productService = new GenericService<>();
 productService.add(new Product());
 

3. Generic Builder Pattern

Builders for domain models can use generics to support fluent API design with type safety:

// Generic Builder class Builder<T> {
 private T instance;
 public Builder(T instance) {
 this.instance = instance;
 

}
 public <V> Builder<T> with(BiConsumer<T, V> setter, V value) {
 setter.accept(instance, value);
 return this;
 

}
 public T build() {
 return instance;
 

}
 

}
 

// Usage User user = new Builder<>(new User()) .with(User::setName, "Alice") .with(User::setAge, 30) .build();
 

Why Important? Enables reusable fluent-style builders across different models without boilerplate.

4. Summary Tips

• Use generics for reusable service layers and avoid repetition in large-scale applications.



• Pair generics with functional interfaces (like `BiConsumer`) for elegant APIs.



• Favor interface-driven design with generics to keep implementations decoupled.

🧠 Section 17: Java 8 Features – Functional Style & Stream API

🔍 Why Java 8 Introduced Functional Style?

• ✅ To simplify bulky boilerplate code, especially in loops and anonymous classes.
• ✅ To bring functional programming to Java using lambdas, stream(), and Optional.
• ✅ To improve readability, maintainability, and performance via lazy evaluation and method chaining.

⚙️ Functional Interfaces

Any interface with a single abstract method is a functional interface.

@FunctionalInterface
interface MyFunctional {

    void execute();



}

Common Built-in Interfaces:

• Predicate<T>: returns boolean
• Function<T,R>: takes T, returns R
• Consumer<T>: takes T, returns void
• Supplier<T>: returns T
• UnaryOperator<T>: takes and returns T

💡 Lambda Expressions

// Traditional
Runnable task = new Runnable() {

    public void run() {

        System.out.println("Running!");

    

}



}
;


// Java 8 Lambda
Runnable task = () -> System.out.println("Running!");

🚀 Stream API: Introduction

The Stream API provides functional-style operations on collections like filtering, mapping, and reducing.

• ✅ Operates on Collections/Arrays using stream()
• ✅ Lazy & efficient (doesn’t execute until terminal operation)
• ✅ Great for filtering, transforming, and reducing data

List<String> names = Arrays.asList("Rahul", "Raj", "Ravi");


names.stream()
     .filter(name -> name.startsWith("R"))
     .sorted()
     .forEach(System.out::println);

Output: Raj, Ravi

🔗 Stream Pipeline Stages

A stream pipeline consists of:

1. Source: Collection, Array, or Generator
2. Intermediate Operations: return another stream (lazy)
3. Terminal Operation: triggers processing and returns result

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);


int result = list.stream()                        // Source
    .filter(n -> n % 2 == 1)                      // Intermediate
    .map(n -> n * n)                              // Intermediate
    .reduce(0, Integer::sum);
                     // Terminal

System.out.println(result);
 // 1² + 3² + 5² = 35

🧰 Common Stream Methods

• filter(Predicate) – Filters elements
• map(Function) – Transforms elements
• sorted(), limit(n), distinct()
• reduce(identity, BinaryOperator) – Aggregates into one result
• collect(Collectors.toList()) – Terminal collector

🧪 Stream with collect() Examples

List<String> names = Arrays.asList("Tom", "Jerry", "Spike");


List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());


System.out.println(upper);
 // [TOM, JERRY, SPIKE]

⚡ Parallel Streams

Java 8 allows processing collections in parallel:

int sum = list.parallelStream()
    .mapToInt(Integer::intValue)
    .sum();

⚠️ Caution: Use parallel streams only when:

• Dataset is large
• Independent operations (no shared mutable state)
• You’ve benchmarked it – not always faster

📦 Real-world Project Use

• 📊 Data Aggregation: Filter and summarize sales records
• 📂 Log Analysis: Map error logs and count types
• 📃 Config Loaders: Read and transform config files line by line

Files.lines(Paths.get("data.txt"))
     .filter(line -> line.contains("ERROR"))
     .map(String::trim)
     .forEach(System.out::println);

📚 Java Collections Framework – Introduction & Core Interfaces

1. What is the Java Collections Framework?

The Java Collections Framework (JCF) is a unified architecture for storing and manipulating groups of data (objects). It includes interfaces, implementations (classes), and algorithms that provide reusable data structures and utilities.

Main Goals:

• Improve performance and consistency
• Encapsulate data structure logic
• Promote reusability and scalability

2. Core Collection Interfaces

All collections inherit from the root interface java.util.Collection. Here's a high-level breakdown:

  
  Collection (root) 
  ├── List (ordered, duplicates allowed)               │ 
      ├── ArrayList                                    │ 
      └── LinkedList                                   │ 
  
  ├── Set (no duplicates)                              │ 
      ├── HashSet                                      │ 
      ├── LinkedHashSet                                │ 
      └── TreeSet (SortedSet)                          │ 

  ├── Queue (FIFO/LIFO structures)                     │ 
      ├── PriorityQueue                                │ 
      └── ArrayDeque                                   │
  
  └── Map (separate root interface for key-value pairs)│ 
      ├── HashMap                                      │
      ├── LinkedHashMap                                │
      └── TreeMap (SortedMap)                          │

      
    
    

Note: Although Map is not a subtype of Collection, it is a part of the Java Collections Framework.

List Implementations (ArrayList vs LinkedList)

1. ArrayList Overview

ArrayList is backed by a dynamically resizable array. It's excellent for random access and frequent reads.

  List<String> 
        cities = new ArrayList<>(); 
        cities.add("Delhi"); 
        cities.add("Mumbai"); 
        System.out.println(cities.get(1)); // Fast O(1) access 
  

• Time Complexity: Get → O(1), Add → O(1) amortized, Remove (middle) → O(n)



• Ideal Use Case: When you need fast random access or use as a stack.

2. LinkedList Overview

LinkedList is backed by a doubly linked list. Good for frequent insertions/removals at ends.

  List<String> names = new LinkedList<>(); 
        names.add("Alice"); names.addFirst("Bob"); 
        names.removeLast(); 
  

• Time Complexity: Add First/Last → O(1), Get(index) → O(n)



• Ideal Use Case: Queue, Deque, when frequent head/tail modifications are needed.

3. Comparison Table

4. Best Practices

• Use ArrayList when access speed is critical and insertions/removals are rare.



• Use LinkedList for frequent add/remove at start or end (Deque).



• Avoid LinkedList for indexed access — it's slower than ArrayList.

  // Fast queue implementation using LinkedList Queue
  <Integer> queue = new LinkedList<>(); 
      queue.add(10); 
      queue.add(20); 
      System.out.println(queue.poll()); // 10 
  

Set and Hashing Fundamentals

1. What is a Set?

A Set in Java is a Collection that contains no duplicate elements. It's useful for lookup-heavy operations like uniqueness checks and fast membership testing.

Set<String> emails = new HashSet<>();
 emails.add("a@example.com");
 emails.add("b@example.com");
 emails.add("a@example.com");
 // Duplicate, won't be added System.out.println(emails);
 

Output: Only unique entries remain.

2. How Hashing Works Internally

• Java uses hashCode() to determine the bucket for a value.



• Then uses equals() to check if the value is equal to existing items.

class User {
 String name;
 int id;
 public int hashCode() {
 return Objects.hash(id);
 
}
 public boolean equals(Object o) {
 if (!(o instanceof User)) return false;
 User other = (User) o;
 return this.id == other.id;
 
}
 
}
 

Note: Always override both hashCode() and equals() when using custom objects in Set or Map.

3. Types of Set Implementations

// TreeSet Example Set<Integer> sorted = new TreeSet<>();
 sorted.add(30);
 sorted.add(10);
 sorted.add(20);
 System.out.println(sorted);
 // [10, 20, 30] 

4. Set Use Cases in CP & Real Systems

• Duplicate detection



• Fast lookups in O(1)



• Maintaining uniqueness (user IDs, tokens)



• Efficient membership tests in dynamic programming, graphs

// CP Example – Unique Sum Pairs Set<String> seen = new HashSet<>();
 for (int i = 0;
 i < n;
 i++) {
 for (int j = i + 1;
 j < n;
 j++) {
 String key = nums[i] + ":" + nums[j];
 seen.add(key);
 
}
 
}
 

Maps (HashMap, LinkedHashMap, TreeMap) and Key-Value Storage

1. What is a Map?

A Map is a key-value pair data structure that allows efficient retrieval of values by keys. Keys are unique, while values can be duplicated.

Map<String, Integer> scores = new HashMap<>();
 scores.put("Alice", 90);
 scores.put("Bob", 85);
 scores.put("Alice", 95);
 // Overwrites previous value System.out.println(scores.get("Alice"));
 // 95 

Note: Keys are unique; duplicate keys replace existing entries.

2. How HashMap Works Internally

• Uses hashCode() of the key to determine the bucket (index).



• If multiple keys hash to the same bucket, uses equals() to differentiate (handles collisions via chaining).



• Since Java 8, it uses balanced trees in buckets with many collisions (for performance).

Map<User, String> map = new HashMap<>();
 map.put(new User(1), "Admin");
 class User {
 int id;
 public int hashCode() {
 return Objects.hash(id);
 
}
 public boolean equals(Object o) {
 return (o instanceof User) && ((User) o).id == this.id;
 
}
 
}
 

Tip: Always override hashCode() and equals() when using custom keys.

3. HashMap vs LinkedHashMap vs TreeMap

// TreeMap auto-sorts keys Map<Integer, String> tree = new TreeMap<>();
 tree.put(3, "Three");
 tree.put(1, "One");
 tree.put(2, "Two");
 System.out.println(tree);
 // {
1=One, 2=Two, 3=Three
}
 

4. Iterating Over Maps

// Key-value loop for (Map.Entry<String, Integer> entry : scores.entrySet()) {
 System.out.println(entry.getKey() + " → " + entry.getValue());
 
}
 

Stream API:

scores.entrySet().stream() .filter(e -> e.getValue() > 80) .forEach(e -> System.out.println(e));
 

5. CP & Real Use Cases of Maps

• Count frequencies (Map<Character, Integer>)



• Graph adjacency list (Map<Node, List<Node>>)



• Cache / Lookup Table



• Memoization in DP

// Count character frequencies Map<Character, Integer> freq = new HashMap<>();
 for (char c : s.toCharArray()) {
 freq.put(c, freq.getOrDefault(c, 0) + 1);
 
}
 

Navigable/Sorted Variants, Queues, Deques & PriorityQueue

1. SortedMap & NavigableMap

These interfaces provide sorted ordering and range-based navigation for maps:

SortedMap<Integer, String> sortedMap = new TreeMap<>();
 sortedMap.put(10, "Ten");
 sortedMap.put(5, "Five");
 System.out.println(sortedMap.firstKey());
 // 5 

NavigableMap adds richer methods:

NavigableMap<Integer, String> navMap = new TreeMap<>(sortedMap);
 System.out.println(navMap.floorKey(7));
 // 5 System.out.println(navMap.ceilingKey(10));
 // 10 System.out.println(navMap.higherKey(10));
 // null 

Use Case: Leaderboard systems, range queries, interval data.

2. SortedSet & NavigableSet

SortedSet is a Set with natural ordering or custom comparator; NavigableSet adds more control:

SortedSet<Integer> sorted = new TreeSet<>();
 sorted.add(10);
 sorted.add(5);
 System.out.println(sorted.first());
 // 5 System.out.println(sorted.last());
 // 10 

NavigableSet<Integer> navSet = new TreeSet<>(sorted);
 System.out.println(navSet.lower(10));
 // 5 System.out.println(navSet.floor(10));
 // 10 

Use Case: Maintain sorted unique elements, perform range retrieval.

3. Queue Interface (FIFO)

Used to store elements in First-In-First-Out order.

Queue<String> queue = new LinkedList<>();
 queue.add("A");
 queue.add("B");
 System.out.println(queue.poll());
 // A System.out.println(queue.peek());
 // B 

Use Case: BFS, order processing, task scheduling.

4. Deque Interface (Double-Ended Queue)

Deque = Double Ended Queue. Can add/remove from both ends.

Deque<Integer> deque = new ArrayDeque<>();
 deque.addFirst(1);
 deque.addLast(2);
 System.out.println(deque.pollLast());
 // 2 System.out.println(deque.pollFirst());
 // 1 

Use Case: Palindrome check, sliding window problems, stack + queue replacement.

5. PriorityQueue (Heap)

PriorityQueue uses natural ordering or a custom comparator (Min Heap by default).

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
 minHeap.add(5);
 minHeap.add(1);
 minHeap.add(3);
 System.out.println(minHeap.poll());
 // 1 

PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
 maxHeap.add(5);
 maxHeap.add(1);
 maxHeap.add(3);
 System.out.println(maxHeap.poll());
 // 5 

Use Case: Dijkstra's algorithm, top-K elements, simulation with prioritized tasks.

Iterators, Fail-Fast vs Fail-Safe, Concurrent Collections

1. Iterators & Enhanced for-loop

Iterators allow sequential access to collection elements. You can remove elements safely during iteration.

List<String> list = new ArrayList<>();
 list.add("A");
 list.add("B");
 list.add("C");
 Iterator<String> it = list.iterator();
 while (it.hasNext()) {
 String value = it.next();
 if ("B".equals(value)) {
 it.remove();
 // Safe removal 
}
 
}
 System.out.println(list);
 // [A, C] 

// Enhanced For-Loop (not safe for removal) for (String s : list) {
 if ("A".equals(s)) list.remove(s);
 // Throws ConcurrentModificationException 
}
 

Tip: Use `Iterator.remove()` instead of `Collection.remove()` inside loops.

2. Fail-Fast vs Fail-Safe Iterators

// Fail-Fast List<String> data = new ArrayList<>(List.of("A", "B"));
 for (String s : data) {
 data.add("C");
 // ConcurrentModificationException 
}
 

// Fail-Safe CopyOnWriteArrayList<String> safeList = new CopyOnWriteArrayList<>();
 safeList.add("A");
 safeList.add("B");
 for (String s : safeList) {
 safeList.add("C");
 // No exception 
}
 System.out.println(safeList);
 // [A, B, C, C] 

3. Concurrent Collections

Java provides concurrent-safe collections for multithreading:

• ConcurrentHashMap – High-performance thread-safe map (segments/locks)



• CopyOnWriteArrayList – Snapshot-style read-safe list



• BlockingQueue (like LinkedBlockingQueue) – Used in producer-consumer patterns



• ConcurrentSkipListMap – Sorted thread-safe map

Map<String, Integer> cmap = new ConcurrentHashMap<>();
 cmap.put("a", 1);
 cmap.put("b", 2);
 cmap.computeIfAbsent("c", k -> 3);
 System.out.println(cmap);
 // {
a=1, b=2, c=3
}
 

BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
 Thread producer = new Thread(() -> {
 try {
 queue.put(10);
 
}
 catch (InterruptedException e) {

}
 
}
);
 Thread consumer = new Thread(() -> {
 try {
 System.out.println(queue.take());
 
}
 catch (InterruptedException e) {

}
 
}
);
 

Utility Classes (Collections, Arrays, Sorting, Binary Search)

1. Collections Utility Class

java.util.Collections is a utility class with static methods for common collection operations.

List<Integer> list = new ArrayList<>(List.of(5, 2, 9));
 Collections.sort(list);
 // Ascending Collections.reverse(list);
 // Descending Collections.shuffle(list);
 // Random shuffle Collections.fill(list, 0);
 // Fill all with 0 

Common Methods:

• sort(), reverse(), shuffle()



• min(), max(), binarySearch()



• frequency(), fill(), copy()



• unmodifiableList() – returns read-only view

int freq = Collections.frequency(List.of("a", "b", "a"), "a");
 System.out.println(freq);
 // Output: 2 List<String> original = new ArrayList<>(List.of("x", "y"));
 List<String> readonly = Collections.unmodifiableList(original);
 // readonly.add("z");
 // Throws UnsupportedOperationException 

2. Arrays Utility Class

java.util.Arrays provides methods to operate on arrays.

int[] arr = {
4, 1, 3
}
;
 Arrays.sort(arr);
 System.out.println(Arrays.toString(arr));
 // [1, 3, 4] int index = Arrays.binarySearch(arr, 3);
 System.out.println("Found at: " + index);
 Arrays.fill(arr, 9);
 System.out.println(Arrays.toString(arr));
 // [9, 9, 9] 

Note: Binary search requires sorted array for correctness.

3. Custom Sorting with Comparator

List<String> names = new ArrayList<>(List.of("John", "Alice", "Bob"));
 Collections.sort(names, new Comparator<String>() {
 public int compare(String a, String b) {
 return b.compareTo(a);
 // Descending 
}
 
}
);
 System.out.println(names);
 // [John, Bob, Alice] 

Java 8+ Tip: Use lambda for cleaner syntax:

Collections.sort(names, (a, b) -> b.compareTo(a));
 

🔍 Deep Copy vs Shallow Copy in Java – Complete Concept

1. What is a Shallow Copy?

A shallow copy copies the structure (e.g., arrays, lists, maps) but not the inner objects. The new object refers to the same inner elements (references) as the original.

class Person {
 String name;
 Person(String name) {
 this.name = name;
 
}
 
}
 List<Person> list1 = new ArrayList<>();
 list1.add(new Person("Alice"));
 // Shallow copy List<Person> list2 = new ArrayList<>(list1);
 // Modify via list2 list2.get(0).name = "Bob";
 System.out.println(list1.get(0).name);
 // Output: Bob – Affected due to shared object 

Why? The list structure is duplicated, but the same `Person` object is referenced in both lists.

2. What is a Deep Copy?

A deep copy duplicates not just the structure, but also the inner elements. This creates fully independent objects.

List<Person> deepList = new ArrayList<>();
 for (Person p : list1) {
 deepList.add(new Person(p.name));
 // New object created 
}
 // Modify deep copy deepList.get(0).name = "Charlie";
 System.out.println(list1.get(0).name);
 // Output: Alice – Not affected 

Why? Deep copy ensures that both the outer and inner layers are duplicated separately.

3. Key Differences

4. Techniques for Deep Copy

• ✔️ Implement Cloneable with clone() method.



• ✔️ Use copy constructors to duplicate nested fields manually.



• ✔️ Use serialization (Gson, Jackson) to deep-copy entire object trees.

// Deep copy via Gson Gson gson = new Gson();
 String json = gson.toJson(originalList);
 List<Person> deepCopy = gson.fromJson(json, new TypeToken<List<Person>>(){

}
.getType());
 

5. Caution with clone()

Java’s built-in clone() method is shallow by default. You must override it to perform deep cloning:

class Person implements Cloneable {
 String name;
 public Person(String name) {
 this.name = name;
 
}
 @Override protected Object clone() {
 return new Person(this.name);
 // Manual deep copy 
}
 
}
 

6. When to Use What?

• ✅ Shallow Copy – For simple data, temporary snapshots, cache keys.



• ✅ Deep Copy – For independent simulation, thread-safe copies, undo-redo systems, or configuration isolation.

🧠 Deep vs Shallow Copy in Java Collections

1. What Is a Shallow Copy?

A shallow copy creates a new collection structure, but the objects inside are still the same references. This means changes to elements reflect in both copies.

List<Person> original = new ArrayList<>();
 original.add(new Person("Alice"));
 // Shallow Copy List<Person> shallow = new ArrayList<>(original);
 shallow.get(0).setName("Bob");
 System.out.println(original.get(0).getName());
 // Output: Bob 

Why? Because both lists reference the same Person object. Only the list structure is duplicated.

2. What Is a Deep Copy?

A deep copy duplicates both the collection structure and all the nested objects. Modifications in one will not affect the other.

List<Person> deep = new ArrayList<>();
 for (Person p : original) {
 deep.add(new Person(p.getName()));
 // Assumes a copy constructor }
 deep.get(0).setName("Charlie");
 System.out.println(original.get(0).getName());
 // Output: Alice 

When Needed? Use deep copies when you want full independence between data structures — common in multithreaded systems, undo histories, simulations, etc.

3. Deep Copy Techniques

• ✅ Implement copy constructors or clone() in custom classes.



• ✅ Use serialization libraries like Jackson, Gson for full object tree duplication.



• ❌ Avoid `Object.clone()` unless fully controlled (it's tricky due to shallow behavior by default).

// Example using Gson for deep copy Gson gson = new Gson();
 String json = gson.toJson(original);
 List<Person> copy = gson.fromJson(json, new TypeToken<List<Person>>(){
}
.getType());
 

Best Practice: Always document whether your copy operation is shallow or deep in shared APIs.

🧠 Competitive Programming & DSA Perspective

This section outlines Java-specific patterns, optimizations, and gotchas that every CP and DSA participant must know.

Each of these tips contributes to either performance optimization, code brevity, or problem-solving accuracy during contests or interviews.

✅ 1. Use static for reusability and speed

In DSA-heavy problems with large recursion trees or multiple utility methods (like gcd(), dfs(), merge()), declaring them as static prevents reallocation and speeds up access.

public class GCDUtil {

    static int gcd(int a, int b) {

        return b == 0 ? a : gcd(b, a % b);

    

}



}

Why: Avoids object allocation cost in CP where main() is the only scope.

✅ 2. Use BufferedReader + StringTokenizer for fast I/O

Scanner is too slow for large inputs. BufferedReader reads a full line, and StringTokenizer splits by whitespace.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

StringTokenizer st = new StringTokenizer(br.readLine());

int a = Integer.parseInt(st.nextToken());

int b = Integer.parseInt(st.nextToken());

When: Input size > 10⁵, avoid Scanner at all costs.

✅ 3. Always use StringBuilder for output

String concatenation in a loop is O(n²) due to immutable string copies. StringBuilder avoids this.

StringBuilder sb = new StringBuilder();

for (int i = 0;
 i < 100000;
 i++) {

    sb.append(i).append(" ");



}

System.out.println(sb);

Why: Prevents TLE in printing answers for large test cases.

✅ 4. Initialize large arrays as static to avoid StackOverflowError

In Java, local variables are allocated on the stack (~1MB/thread). Arrays with size > 10⁶ should be global/static.

static int[] freq = new int[1000001];

Use Case: Prefix sums, frequency arrays, sieve, DP.

✅ 5. Use final static for constants

Avoid magic numbers and enable compile-time optimizations.

final static int MOD = 1_000_000_007;

final static int INF = Integer.MAX_VALUE;

When: Needed across multiple methods or test cases.

✅ 6. Use HashMap and HashSet instead of arrays for sparse/negative keys

Avoid allocating large arrays when values are sparse or range includes negative numbers. Use maps to store only required keys.

HashMap<Integer, Integer> freq = new HashMap<>();

for (int x : arr) {

    freq.put(x, freq.getOrDefault(x, 0) + 1);



}

When: You don’t know the input range or it’s very wide/negative.

✅ 7. Use Arrays.sort() for primitives and Arrays.sort(obj[], Comparator) for pairs

Default sort works only for primitives. Use custom sort for objects or 2D arrays.

Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));

Why: Crucial in greedy, sweep line, and scheduling problems.

✅ 8. Use prefix sum for range queries

Prefix sums allow O(1) query after O(n) preprocessing.

int[] prefix = new int[n+1];

for (int i = 1;
 i <= n;
 i++) {

    prefix[i] = prefix[i-1] + arr[i-1];



}

// Range sum from l to r:
int sum = prefix[r] - prefix[l-1];

Why: A must-know trick in array segment problems.

✅ 9. Use binary search pattern correctly with while (low <= high)

Avoid infinite loops by updating mid carefully and always shifting bounds.

int low = 0, high = n - 1;

while (low <= high) {

    int mid = (low + high) / 2;

    if (arr[mid] == target) return mid;

    else if (arr[mid] < target) low = mid + 1;

    else high = mid - 1;



}

Use Case: Binary search, lower_bound/upper_bound replacements in Java.

✅ 10. Use space reuse tricks in DP

You can often reduce a 2D DP to 1D when only last row is needed.

int[] dp = new int[n+1];

for (int i = 1;
 i <= n;
 i++) {

    for (int j = k;
 j >= 0;
 j--) {

        dp[j] = Math.max(dp[j], value + dp[j - weight]);

    

}



}

Why: Memory optimization in knapsack, LIS, and similar problems.

✅ 11. Use Sliding Window Technique for subarray/window problems

Maintain a window [left, right] that slides across the array, adjusting when a condition is violated or satisfied.

int left = 0, sum = 0, minLen = Integer.MAX_VALUE;

for (int right = 0;
 right < arr.length;
 right++) {

    sum += arr[right];

    while (sum >= target) {

        minLen = Math.min(minLen, right - left + 1);

        sum -= arr[left++];

    

}



}

Use Case: Minimum window sum, distinct character substring, etc.

✅ 12. Use Two Pointer Technique for sorted arrays/lists

Two indices are moved independently to solve in linear time instead of O(n²).

int i = 0, j = arr.length - 1;

while (i < j) {

    int sum = arr[i] + arr[j];

    if (sum == target) {

        return true;

    

}
 else if (sum < target) {

        i++;

    

}
 else {

        j--;

    

}



}

Use Case: Pair sum, merge sorted arrays, unique triplets.

✅ 13. Use Monotonic Stack to find nearest greater/smaller elements

Maintain a stack that keeps elements in increasing/decreasing order.

Stack<Integer> stack = new Stack<>();

int[] nge = new int[n];

for (int i = n - 1;
 i >= 0;
 i--) {

    while (!stack.isEmpty() && arr[stack.peek()] <= arr[i]) {

        stack.pop();

    

}

    nge[i] = stack.isEmpty() ? -1 : arr[stack.peek()];

    stack.push(i);



}

Use Case: Next Greater Element, histogram area, stock span.

✅ 14. Use Bitmasking for subset problems with small n (n ≤ 20)

You can iterate over all 2ⁿ subsets using bitmask representation.

for (int mask = 0;
 mask < (1 << n);
 mask++) {

    for (int i = 0;
 i < n;
 i++) {

        if ((mask & (1 << i)) != 0) {

            // element i is in subset
        

}

    

}



}

Use Case: Subset sum, combinatorics, K-th bit toggling.

✅ 15. Use PriorityQueue with custom comparator for greedy/Dijkstra

Java’s PriorityQueue allows custom ordering using lambdas or comparator classes.

PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);

// Format: [node, weight]
pq.offer(new int[]{
0, 0

}
);

Use Case: Shortest path, top K elements, merge K sorted lists.

✅ 16. Use Iterative DFS/BFS with Queue/Stack to avoid Recursion Limits

Java doesn't allow tail-call optimization. Prefer iterative BFS/DFS for large graphs.

// BFS example
Queue<Integer> queue = new LinkedList<>();

boolean[] visited = new boolean[n];

queue.add(start);

visited[start] = true;


while (!queue.isEmpty()) {

    int node = queue.poll();

    for (int nei : graph[node]) {

        if (!visited[nei]) {

            visited[nei] = true;

            queue.add(nei);

        

}

    

}



}

Use Case: Shortest path in unweighted graph, flood fill, connected components.

✅ 17. Use Parent Array for Union-Find (Disjoint Set)

Classic trick to solve dynamic connectivity, Kruskal’s MST, bipartite check, etc.

int[] parent = new int[n];

for (int i = 0;
 i < n;
 i++) parent[i] = i;


int find(int x) {

    return parent[x] == x ? x : (parent[x] = find(parent[x]));
 // path compression


}


void union(int a, int b) {

    parent[find(a)] = find(b);



}

Use Case: Union-find with cycle detection, connected components.

✅ 18. Use DFS with Depth Array for Binary Tree Depth / Ancestor Traversal

void dfs(int node, int parent, int depth) {

    d[node] = depth;

    for (int child : tree[node]) {

        if (child != parent) {

            dfs(child, node, depth + 1);

        

}

    

}



}

Use Case: Tree diameter, LCA, Euler tour for trees.

✅ 19. For Matrix Traversals, always use direction arrays

int[] dx = {
-1, 1, 0, 0

}
;

int[] dy = {
0, 0, -1, 1

}
;


for (int d = 0;
 d < 4;
 d++) {

    int nx = x + dx[d];

    int ny = y + dy[d];

    if (nx >= 0 && ny >= 0 && nx < n && ny < m && grid[nx][ny] == 1) {

        // valid next cell
    

}



}

Use Case: Flood fill, pathfinding, island count, snake/rat/maze problems.

✅ 20. Use Backtracking with Early Pruning

Avoid exploring impossible branches early to reduce time complexity.

void solve(int level, int sum) {

    if (sum > target) return;
 // prune
    if (level == arr.length) {

        if (sum == target) count++;

        return;

    

}

    solve(level + 1, sum);

    solve(level + 1, sum + arr[level]);



}

Use Case: Subset sum, combinations, N-Queens, Sudoku solver.

✅ 21. Use Segment Tree for range queries with updates

Segment trees are efficient for solving problems that require both range queries and point/range updates in logarithmic time.

int[] tree = new int[4 * n];


void build(int node, int l, int r, int[] arr) {

    if (l == r) {

        tree[node] = arr[l];

    

}
 else {

        int mid = (l + r) / 2;

        build(2*node, l, mid, arr);

        build(2*node+1, mid+1, r, arr);

        tree[node] = tree[2*node] + tree[2*node+1];

    

}



}

Use Case: Range sum, range min/max, point update, RMQ, inversion count.

✅ 22. Use Binary Indexed Tree (Fenwick Tree) for cumulative operations

Simpler than segment tree and ideal when only range queries + point updates are needed.

int[] BIT = new int[n+1];


void update(int i, int val) {

    while (i <= n) {

        BIT[i] += val;

        i += i & -i;

    

}



}


int query(int i) {

    int sum = 0;

    while (i > 0) {

        sum += BIT[i];

        i -= i & -i;

    

}

    return sum;



}

Use Case: Prefix sum, inversion count, frequency queries.

✅ 23. Use Trie for efficient prefix-based lookups

A Trie allows fast prefix matching and autocomplete-like logic in O(length) time.

class TrieNode {

    TrieNode[] children = new TrieNode[26];

    boolean isEnd;



}


void insert(TrieNode root, String word) {

    for (char c : word.toCharArray()) {

        int idx = c - 'a';

        if (root.children[idx] == null) root.children[idx] = new TrieNode();

        root = root.children[idx];

    

}

    root.isEnd = true;



}

Use Case: Word dictionary, prefix checks, longest common prefix.

✅ 24. Use Fast Exponentiation for modular pow operations

Reduce time complexity of power operations from O(n) to O(log n).

long modPow(long a, long b, long mod) {

    long res = 1;

    while (b > 0) {

        if ((b & 1) == 1)
            res = (res * a) % mod;

        a = (a * a) % mod;

        b >>= 1;

    

}

    return res;



}

Use Case: Big number exponentiation, mod inverse, Fermat’s theorem.

✅ 25. Template your contest code to save time

static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

static PrintWriter out = new PrintWriter(System.out);

static StringTokenizer st;


static String next() throws IOException {

    while (st == null || !st.hasMoreTokens())
        st = new StringTokenizer(br.readLine());

    return st.nextToken();



}


static int ni() throws IOException {
 return Integer.parseInt(next());
 

}

static long nl() throws IOException {
 return Long.parseLong(next());
 

}

Why: Saves 5–10 minutes in every contest and reduces boilerplate typing.

✅ 26. Know when to use Greedy vs DP

Greedy works when choosing a locally optimal solution always leads to a global optimum. If choices affect future decisions, use DP.

// Greedy: Activity Selection
Arrays.sort(intervals, (a, b) -> a[1] - b[1]);

int count = 1, end = intervals[0][1];

for (int i = 1;
 i < intervals.length;
 i++) {

    if (intervals[i][0] >= end) {

        count++;

        end = intervals[i][1];

    

}



}

Tip: Try greedy first. If you hit counterexamples, shift to DP.

✅ 27. Use TreeMap to simulate a Multiset (Ordered Map)

Java lacks a built-in multiset. You can use TreeMap<Integer, Integer> to simulate sorted frequency counts.

TreeMap<Integer, Integer> map = new TreeMap<>();

map.put(val, map.getOrDefault(val, 0) + 1);
  // Insert
map.put(val, map.get(val) - 1);
              // Erase
if (map.get(val) == 0) map.remove(val);

Use Case: Median in sliding window, greedy matching, floor/ceiling queries.

✅ 28. Use Randomized Techniques to avoid worst-case scenarios

Shuffling before sort helps avoid degenerate inputs and TLE in adversarial tests.

Collections.shuffle(Arrays.asList(arr));

Arrays.sort(arr);

Use Case: Quicksort-based algorithms, randomized hashing, hash maps.

✅ 29. Use Polynomial Hashing for string matching

Avoid TLE and collisions in string comparison by hashing prefix substrings.

final int p = 31, mod = 1_000_000_009;

long[] pow = new long[n];

pow[0] = 1;

for (int i = 1;
 i < n;
 i++)
    pow[i] = (pow[i-1] * p) % mod;

Use Case: Substring equality check in O(1), rolling hash, KMP-alternatives.

✅ 30. Apply Grundy Numbers in Game Theory

Sprague-Grundy theorem helps solve "take-away" style games using XOR of Grundy numbers.

int[] grundy = new int[n+1];

for (int i = 1;
 i <= n;
 i++) {

    HashSet<Integer> set = new HashSet<>();

    for (int x : moves)
        if (i - x >= 0) set.add(grundy[i - x]);

    // mex logic
    int g = 0;

    while (set.contains(g)) g++;

    grundy[i] = g;



}

Use Case: Nim game, XOR-based games, stone removal games.

✅ 31. Build a Custom Debug Print Utility

Create your own toggleable debug print function to avoid clutter and make contest testing easier.

static boolean DEBUG = false;


static void debug(Object... args) {

    if (!DEBUG) return;

    for (Object o : args) System.out.print(o + " ");

    System.out.println();



}

Use Case: Toggle debug logs during test case simulation.

✅ 32. Automate Local Testing with a Custom Input Runner

Use a main wrapper or file reader for local testing with multiple inputs.

System.setIn(new FileInputStream("input.txt"));

System.setOut(new PrintStream(new FileOutputStream("output.txt")));

Use Case: Simulating Codeforces/Leetcode input files.

✅ 33. Write a Stress Test to Compare Naive vs Optimized

Test correctness of your optimized logic by comparing with brute force over random test data.

for (int t = 0;
 t < 1000;
 t++) {

    int[] input = generateRandomInput();

    int brute = solveBrute(input);

    int fast = solveOptimized(input);

    if (brute != fast) {

        System.out.println("Mismatch found!");

        break;

    

}



}

Use Case: Debug hidden corner cases not exposed by sample inputs.

✅ 34. Design Edge Case Generators

Always test on: empty input, max constraints, all same values, zig-zag patterns, alternating values.

• Sorted, reverse-sorted, and all-duplicate arrays
• Max values, min values, alternating sequences
• Graphs: tree, cycle, disconnected, fully connected

✅ 35. Use Timer to Benchmark Blocks of Code

Time your functions when testing time-intensive logic locally.

long start = System.currentTimeMillis();

// block to measure
System.out.println("Time: " + (System.currentTimeMillis() - start) + " ms");

Use Case: Check feasibility of brute force or hybrid approach under TLE limit.

🎯 Final Checklist Before Submitting:

• ✅ Remove all debug/print statements
• ✅ Use fast I/O: BufferedReader + PrintWriter
• ✅ Avoid unnecessary object creation
• ✅ Check for off-by-one or wrong bounds in loops
• ✅ Validate constraints for integer vs long overflows
• ✅ Predefine MOD, INF, template I/O functions
• ✅ Run on custom edge tests before final submit

🧠 Competitive Programming & DSA Perspective – OOP in Java

✅ 1. Use Classes to Represent Structured Data Clearly

Instead of managing parallel arrays or multiple variables, use classes to encapsulate properties like coordinates, edges, or tasks.

class Point {

    int x, y;

    Point(int x, int y) {
 this.x = x;
 this.y = y;
 

}



}

Use Case: Geometry problems, segment sweep, graphs.

✅ 2. Implement Comparable for Custom Sorting

Use implements Comparable in your classes to sort by custom criteria. This is often needed in greedy, scheduling, and graph problems.

class Job implements Comparable<Job> {

    int profit, deadline;

    public int compareTo(Job j) {

        return j.profit - this.profit;
 // descending
    

}



}

Use Case: Job sequencing, interval scheduling.

✅ 3. Use Getters/Setters in Templates for Reusability

Avoid direct field access if your class is reused across test cases or modified under constraints.

public class Edge {

    private int u, v, weight;


    public Edge(int u, int v, int w) {

        this.u = u;
 this.v = v;
 this.weight = w;

    

}


    public int getU() {
 return u;
 

}

    public int getWeight() {
 return weight;
 

}



}

Why: Promotes clean design, makes it easier to debug/test specific properties.

✅ 4. Group Operations with Method Encapsulation

Instead of writing separate utility functions, encapsulate logic within object methods. This is especially useful in recursive backtracking and simulation problems.

class Knight {

    int x, y;

    boolean isSafe(int[][] board) {

        return x >= 0 && y >= 0 && x < 8 && y < 8 && board[x][y] == 0;

    

}



}

Use Case: Chess board problems, grid simulations.

✅ 5. Use Factory Patterns in CP Templates (Advanced)

In contests with multiple object types (like building strategy patterns), you can build utility factory methods.

class ShapeFactory {

    static Shape createCircle(int r) {
 return new Circle(r);
 

}

    static Shape createSquare(int s) {
 return new Square(s);
 

}



}

Use Case: Helps in creating reusable simulation templates in advanced OOP-heavy CP rounds.

✅ 6. Override equals() and hashCode() for Set/Map Usage

If you use custom objects in HashSet or HashMap, override both equals() and hashCode(). Otherwise, they’ll use memory addresses and fail to match duplicates.

class State {

    int x, y;


    @Override
    public boolean equals(Object o) {

        if (this == o) return true;

        if (!(o instanceof State)) return false;

        State s = (State) o;

        return x == s.x && y == s.y;

    

}


    @Override
    public int hashCode() {

        return 31 * x + y;

    

}



}

Use Case: BFS visited states, grid puzzles, shortest path with state memory.

✅ 7. Override toString() for Easier Debugging

A well-implemented toString() helps you debug fast without printing each field manually.

class Pair {

    int a, b;

    public String toString() {

        return "(" + a + ", " + b + ")";

    

}



}

Use Case: Debugging object state in contest templates or during testing.

✅ 8. Use Polymorphism for Strategy Design in Simulations

Model different actions using a base interface or abstract class, and override behavior.

interface Move {

    void perform();



}


class Jump implements Move {

    public void perform() {
 System.out.println("Jump");
 

}



}


class Run implements Move {

    public void perform() {
 System.out.println("Run");
 

}



}

Use Case: Turn-based simulation, grid traversal variants, battle simulation problems.

✅ 9. Encapsulate Union-Find (Disjoint Set Union) into a Reusable Class

Don’t rewrite DSU every time. Use a class that hides find and union logic inside a clean interface.

class DSU {

    int[] parent;


    DSU(int n) {

        parent = new int[n];

        for (int i = 0;
 i < n;
 i++) parent[i] = i;

    

}


    int find(int x) {

        return parent[x] == x ? x : (parent[x] = find(parent[x]));

    

}


    void union(int a, int b) {

        parent[find(a)] = find(b);

    

}



}

Use Case: Connected components, Kruskal’s MST, cycle detection.

✅ 10. Use TreeNode, GraphNode, and Edge Classes for Reusability

Instead of coding a graph/tree from scratch every time, reuse OOP-style node classes in your templates.

class TreeNode {

    int val;

    TreeNode left, right;



}


class GraphNode {

    int id;

    List<GraphNode> neighbors;



}

Use Case: Leetcode-style tree/graph problems — keeps code modular and readable.

✅ 11. Use Custom Comparators to Build Priority Queues on Objects

In Dijkstra, A*, greedy matchings — priority queues over objects are critical. Use lambda or Comparable/Comparator.

class Node {

    int id, dist;

    Node(int i, int d) {
 id = i;
 dist = d;
 

}



}


PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> a.dist - b.dist);

Use Case: Graph shortest path, task prioritization, simulation.

✅ 12. Use Enums to Represent Modes/States Cleanly

Use enum to represent direction, type, or game states instead of plain strings or magic numbers.

enum Direction {

    UP, DOWN, LEFT, RIGHT


}


Direction move = Direction.UP;

Use Case: Grid movement, simulation logic, game-style logic branches.

✅ 13. Use Static Utility Classes for Templates

Create static classes for math, graph, array, or string utilities to reduce clutter and speed up development during contests.

public class MathUtil {

    public static long gcd(long a, long b) {

        return b == 0 ? a : gcd(b, a % b);

    

}


    public static long modAdd(long a, long b, long mod) {

        return (a + b) % mod;

    

}



}

Use Case: Reusable contest library – reduces bugs and retyping under pressure.

✅ 14. Protect Against Null/Empty States with Safe Constructors

In fast-paced coding, bugs often arise from uninitialized fields. Protect your templates with default constructors or checks.

class Pair {

    int x, y;

    Pair(int x, int y) {

        this.x = x;

        this.y = y;

    

}


    static Pair empty() {
 return new Pair(-1, -1);
 

}



}

Use Case: Return safe placeholder values instead of null from search/lookup methods.

✅ 15. Use Object-Oriented Backtracking with Clean State

Wrap state into objects so you don’t manually undo changes — just pass cloned state to the next recursion level.

class Board {

    char[][] grid;


    Board cloneBoard() {

        char[][] newGrid = new char[grid.length][];

        for (int i = 0;
 i < grid.length;
 i++)
            newGrid[i] = grid[i].clone();

        return new Board(newGrid);

    

}



}

Use Case: Sudoku, N-Queens, board simulations with backtracking.

✅ 16. Use Immutable Data Patterns Where Safe

Avoid bugs from shared references by using final fields and constructor initialization. This is especially useful in recursive or parallel logic.

class Move {

    final int dx, dy;

    Move(int dx, int dy) {

        this.dx = dx;

        this.dy = dy;

    

}



}

Use Case: Grid moves, immutable coordinates, recursion states.

✅ 17. Enable Fluent APIs with Method Chaining

Return this from setters or modifiers to chain calls and reduce verbosity.

class Builder {

    private int a, b;

    Builder setA(int a) {
 this.a = a;
 return this;
 

}

    Builder setB(int b) {
 this.b = b;
 return this;
 

}



}

Use Case: DSL-style config creation, test builders, chained state configuration.

✅ 18. Use Object Pooling to Optimize Memory Use in Large Simulations

If object creation is frequent and heavy (e.g., during test cases or simulation steps), reuse instead of creating new instances.

Queue<Node> pool = new LinkedList<>();

Node getNode() {

    return pool.isEmpty() ? new Node() : pool.poll();



}

Use Case: Heavy simulations with >10⁶ iterations, test case batch runners.

✅ 19. Sort by Composite Keys Using Comparator Chaining

In contests, sort objects by multiple conditions — e.g., primary by cost, secondary by time.

Arrays.sort(arr, Comparator
    .comparingInt((Item x) -> x.cost)
    .thenComparingInt(x -> x.time));

Use Case: Task selection, job scheduling, DP state ranking.

✅ 20. Template-Friendly Object Checklist (Recap)

• ✔ Use toString() for debug
• ✔ Override equals() & hashCode() for HashSet/Map
• ✔ Implement Comparable or use Comparator
• ✔ Keep constructors lightweight & safe
• ✔ Group operations inside methods (not as global functions)
• ✔ Prefer immutability in recursion/backtracking

🏆 Competitive Programming & DSA Perspective – Java Classes, Objects & Memory

✅ 1. Prefer Static Methods for Speed

In competitive programming, using static methods is faster and more memory efficient for recursion or utility functions, since they don't require object instantiation.

public class GCDUtil {

    public static int gcd(int a, int b) {

        return (b == 0) ? a : gcd(b, a % b);

    

}


    public static void main(String[] args) {

        System.out.println(gcd(12, 8));
 // Output: 4
    

}



}

✅ 2. Use Final Arrays for Safer Constants

When using direction arrays in BFS/DFS or static lookup tables in DP, mark them as final to prevent accidental overwriting.

final int[] dx = {
-1, 1, 0, 0

}
;

final int[] dy = {
0, 0, -1, 1

}
;

This ensures constant memory layout and avoids bugs during iteration.

✅ 3. Garbage Collection Awareness

Large lists, hash maps, or matrices should be cleaned up after use to avoid memory bloat.

List<Integer> temp = new ArrayList<>();

// after processing
temp.clear();
 // OR temp = null;
 if it won't be reused

Avoid holding unnecessary references—let the GC free memory for the next part of your logic.

✅ 4. Understand Stack vs Heap

In recursion-heavy problems, understanding stack depth is crucial to avoid StackOverflowError.

int dfs(int node, int depth) {

    if (depth > MAX_DEPTH) return 0;

    return dfs(node, depth + 1);



}

Each recursive call consumes stack space. For deep trees, switch to iterative logic using your own stack.

✅ 5. Use Custom Classes for State Compression

When dealing with graph traversal (e.g., Dijkstra, A*), it's cleaner and safer to create a class representing state.

class State {

    int node, cost;

    State(int n, int c) {
 node = n;
 cost = c;
 

}



}

Such structure improves readability and avoids passing multiple arrays/queues.

✅ 6. Object Reuse for Performance

Creating new objects inside a loop or recursive call slows down execution and stresses the GC.

Best Practice: Create the object once and reuse it by updating its fields.

class Point {

    int x, y;



}

Point reusable = new Point();

for (int i = 0;
 i < N;
 i++) {

    reusable.x = i;

    reusable.y = 0;

    // Use reusable in your logic


}

This avoids repeated heap allocations and improves performance.

✅ 7. Always Override equals() and hashCode()

When using custom objects in HashMap or HashSet, Java uses equals() and hashCode() to determine key equality.

class Cell {

    int x, y;


    @Override
    public boolean equals(Object o) {

        if (this == o) return true;

        if (!(o instanceof Cell)) return false;

        Cell cell = (Cell) o;

        return x == cell.x && y == cell.y;

    

}


    @Override
    public int hashCode() {

        return 31 * x + y;

    

}



}

Failure to override may cause logic errors in visited node tracking, caching, and memoization.

✅ 8. Use Arrays Instead of Objects for Graphs

In CP problems involving graphs, using arrays is often more memory-efficient and cache-friendly.

// Instead of: class Edge {
 int u, v;
 

}

// Use:
List<int[]>[] graph = new ArrayList[N];

graph[i].add(new int[]{
to, weight

}
);

This allows fewer class lookups and faster traversal in contests.

✅ 9. Group Multi-Dimensional DP States in One Class

When memoizing over multiple parameters, grouping them into one object avoids parallel arrays and improves readability.

class DPState {

    int i, j, steps;

    DPState(int i, int j, int s) {
 this.i = i;
 this.j = j;
 this.steps = s;
 

}



}

Combine this with a Map<DPState, Integer> for clean memoization.

✅ 10. Java is Pass-by-Value (Object Reference is a Value)

Java passes object references by value. This means the object itself is not copied, but the reference is.

void update(Node n) {

    n.value = 10;
  // affects original
    n = new Node();
 // no effect outside


}

Be careful during backtracking or recursion—if you reassign the object, it won’t affect the caller’s reference.

✅ 11. Optimize Memory Using Primitive Arrays and Bit Manipulation

In memory-tight problems, use char[], int[], or bitmasks instead of object-heavy structures.

// Use bitmasking for visited states (e.g., subset DP)
int mask = 0;

mask |= (1 << i);
 // mark i-th bit as visited
if ((mask & (1 << i)) != 0) {
 /* i-th is already visited */ 

}

This reduces space and often speeds up lookup due to compact structure.

✅ 12. Immutable Objects for Parallel Processing

Immutable objects ensure thread safety when solving problems in multithreaded environments like Java ForkJoinPool.

final class Result {

    final int sum, count;

    Result(int sum, int count) {

        this.sum = sum;
 this.count = count;

    

}



}

Useful in backtracking-heavy problems to avoid shared-state corruption.

✅ 13. Integer Cache Awareness

Java caches boxed Integer values between -128 to 127. Comparing outside this range with == may fail.

Integer a = 1000, b = 1000;

System.out.println(a == b);
 // false!

Always use a.equals(b) to ensure proper logical equality.

✅ 14. Static Factory for Reusable Defaults

Instead of creating new objects in loops, use factory methods to return default static instances if possible.

class TreeNodeFactory {

    static final TreeNode EMPTY = new TreeNode(-1);

    public static TreeNode emptyNode() {
 return EMPTY;
 

}



}

This helps in segment trees, tries, or flow networks where you often need a default object.

✅ 15. Avoid Deep Object Nesting for Performance

Too many layers (e.g., graph[node].edges[i].to) result in frequent pointer chasing and poor cache locality.

// Instead of deeply nested object access, flatten:
class Edge {

    int to, weight;



}

List<Edge>[] graph = new ArrayList[N];

Flattening improves memory locality and is crucial in large datasets and simulation problems.

🎯 Competitive Programming & DSA Perspective

📌 Focus: Scope Management, Input Optimization, Code Modularity

✅ 1. Limit Scope to Prevent Accidental Access

Use private or default access for all helper functions in your competitive programming templates. This avoids unintended modifications or access across unrelated code blocks.

private static int gcd(int a, int b) {

    return b == 0 ? a : gcd(b, a % b);



}

✅ 2. Class Isolation for Different Algorithms

If your contest solution contains multiple independent strategies, wrap each inside separate classes with controlled access.

class BinarySearchSolver {

    static int solve(int[] arr, int target) {
 ... 

}



}


class TwoPointerSolver {

    static int findPairSum(int[] arr, int sum) {
 ... 

}



}

✅ 3. Use public only for Main Entry

In contests using Java, always mark your main class public and file name should match:

public class Main {

    public static void main(String[] args) {

        // Solution here
    

}



}

✅ 4. Internal Testing with Package Isolation

If allowed to submit multiple files (e.g., in take-home assessments), split test and solution packages.

// com.cp.solvers
class Solver {
 ... 

}


// com.cp.test
class TestCases {

    // use protected Solver members if needed


}

✅ 5. Simulate Restricted Scopes in IDE

While practicing, mimic online judge environments by using package-private access (i.e., no modifier).

• Forces you to group all related logic into the same file
• Improves modularity under constraints

✅ 6. Avoid Overexposing Constants

Use private static final for internal constants to prevent accidental changes in large solutions:

private static final int MOD = 1_000_000_007;

private static final int MAX = 100_005;

Access them only within the current class to prevent pollution of shared state across utility classes.

✅ 7. Package-Scoped Caching for Memoization

For recursive problems with overlapping subproblems (e.g., DP), control cache access via default/package-private modifiers:

class FibonacciSolver {

    static int[] memo = new int[100];

    
    static int fib(int n) {

        if (n <= 1) return n;

        if (memo[n] != 0) return memo[n];

        return memo[n] = fib(n - 1) + fib(n - 2);

    

}



}

✅ 8. Minimize Use of protected

In CP and DSA, inheritance is rare during contest use. Use protected only if you're explicitly subclassing test cases or base strategy templates.

✅ 9. Auto-Submission Safety

Judge platforms often extract only the public class with main(). If helper classes are public too, it may lead to conflicts or errors:

// ❌ Don't do this in contests:
public class Helper {
 ... 

}

public class Main {
 public static void main(String[] args) {
 ... 

}
 

}

✅ 10. Maintain Readability with Grouped Access

Group similar functionality under the same class with scoped methods instead of scattering accessors across files:

class GraphUtils {

    private int[] visited;

    void dfs(int node) {
 ... 

}



}

✅ 11. Controlled Access to Custom Data Structures

If you implement a custom class (e.g., Segment Tree, Fenwick Tree), use private fields with public or default methods.

class SegmentTree {

    private int[] tree;


    SegmentTree(int[] arr) {
 ... 

}


    int query(int l, int r) {
 ... 

}

    void update(int index, int value) {
 ... 

}



}

✅ 12. Use Default Access for Time-Limited Debugging

During contests, if you need to quickly test internal logic, you can use package-private (no modifier) methods temporarily.

// Accessible in same file or package
int bruteForce(int[] arr) {
 ... 

}

✅ 13. Avoid Static Abuse for Global States

Don’t expose public static variables unless absolutely necessary (e.g., constants).

public static int ans;
 // ❌ can lead to cross-test pollution

✅ 14. Controlled Inheritance in Strategy Design

In advanced problems (e.g., Codeforces Div. 1), you may design base solver strategies:

abstract class Solver {

    abstract int solve(int[] input);



}


class BruteForceSolver extends Solver {

    int solve(int[] input) {
 ... 

}



}

✅ 15. Entry-Point Safety for Team Submissions

In team-based contests or code reviews, use access modifiers to prevent teammates from invoking experimental/test code accidentally.

private static void testGraphUtils() {
 ... 

}
 // not part of final submission

🎯 Competitive Programming & DSA Perspective – Control Flow in Java (Part 1)

In competitive programming, control flow mastery can directly impact runtime, readability, and edge case handling. Here are powerful insights and examples that translate to better problem-solving:

🔸 1. Early Return to Minimize Nesting

Instead of writing deeply nested conditions, use early return statements to guard invalid cases:

public void solve(int n) {

  if (n <= 0) return;
 // Guard clause
  if (n == 1) {

    System.out.println("Base case");

    return;

  

}

  // Core logic


}

Why? It reduces indentation and improves readability in timed contests.

🔸 2. Skipping Iterations with continue

Use continue to ignore unneeded cases cleanly:

for (int i = 0;
 i < n;
 i++) {

  if (arr[i] % 2 == 0) continue;
  // Skip even numbers
  System.out.println(arr[i]);
     // Process only odd


}

🔸 3. Efficient Searching with break

Use break to stop iteration as soon as your answer is found:

boolean found = false;

for (int i = 0;
 i < arr.length;
 i++) {

  if (arr[i] == target) {

    found = true;

    break;
 // exit early, avoid unnecessary computation
  

}



}

🔸 4. Loop Labels for Nested Breaks

In matrix/grid/graph traversal problems, exit multiple nested loops using labels:

search:
for (int i = 0;
 i < N;
 i++) {

  for (int j = 0;
 j < M;
 j++) {

    if (grid[i][j] == 'X') {

      System.out.println("Found at " + i + "," + j);

      break search;
  // exits both loops
    

}

  

}



}

✅ Useful in 2D problems like flood fill, pathfinding, knight moves, etc.

🔸 5. Using Ternary Operators Smartly

In CP, ternary expressions reduce verbosity (but don’t overuse):

int result = (a > b) ? a : b;
  // max of a, b

Avoid in logic-heavy conditions, but fine for one-liners or scoring in problems like: "Given two integers A and B, print the max."

🎯 Competitive Programming & DSA Perspective – Control Flow in Java (Part 2)

🔸 6. Limiting Iterations for Efficiency

When handling large input constraints (like N ≤ 10⁶), bounded loops help prevent TLE:

for (int i = 0;
 i < Math.min(n, 100000);
 i++) {

  // Logic for only first 10^5 items


}

✅ Used when only top K elements or prefix of data is needed.

🔸 7. Binary Search Loop Template

Classic control flow structure you must master:

int l = 0, r = n - 1;

while (l <= r) {

  int mid = l + (r - l) / 2;

  if (arr[mid] == target) return mid;

  else if (arr[mid] < target) l = mid + 1;

  else r = mid - 1;



}

🔥 Found in 100+ problems: arrays, bitmasking, prefix sums, etc.

🔸 8. Recursion with Early Return

When using DFS, backtracking, etc., return as soon as valid condition met:

boolean dfs(int node) {

  if (node == target) return true;

  visited[node] = true;

  for (int neighbor : graph[node]) {

    if (!visited[neighbor] && dfs(neighbor)) return true;

  

}

  return false;



}

🔸 9. Flag Variables vs Return Flow

Use flags only when needed. Sometimes returning directly improves clarity:

// Instead of this:
boolean found = false;

for (...) {

  if (...) found = true;



}

// Do this:
if (...) return true;

🔸 10. Simulation with Loop Control

Simulate real-world flow (queue, game, scheduling) by carefully managing loop variables:

while (!q.isEmpty()) {

  int size = q.size();

  for (int i = 0;
 i < size;
 i++) {

    // BFS logic or state change
  

}



}

🔸 11. Handling Multiple Test Cases

Template for handling T test cases efficiently:

int T = sc.nextInt();

while (T-- > 0) {

  solve();



}

✅ Helps in contests like Codeforces, AtCoder, etc.

🔸 12. Avoiding Deep Nesting

Nested if/else harms readability. Prefer return and simplify:

// Instead of:
if (a) {

  if (b) {

    if (c) doStuff();

  

}



}


// Use:
if (!a || !b || !c) return;

doStuff();

🔸 13. Inline Loop Variable Tricks

Iterating in reverse or skipping by step size:

for (int i = n - 1;
 i >= 0;
 i--)  // reverse
for (int i = 0;
 i < n;
 i += 2)    // every 2nd element

🔸 14. Trick: Nested Loops for Pairwise Combos

for (int i = 0;
 i < n;
 i++) {

  for (int j = i + 1;
 j < n;
 j++) {

    // pairs: (i, j)
  

}



}

Time Complexity: O(n²). Only use when n ≤ 10³.

🔸 15. Caution with Loops on Input-Modified Arrays

Don’t use for-each if you’re modifying elements — it uses internal copies:

// Incorrect:
for (int x : arr) x = 0;
  // Won’t update original array

// Correct:
for (int i = 0;
 i < arr.length;
 i++) arr[i] = 0;

🔥 Mastering these tricks and control structures gives you a real edge in contests. Control flow = Code control = Performance control.

🎯 Competitive Programming & DSA Perspective: Arrays & Collections (Part 1)

✅ Tip 1: Use Arrays for Predictable Indexing

Arrays are contiguous blocks of memory with O(1) random access.

They're ideal for fixed-size data structures like prefix sums, frequency maps, or DP arrays.

// Prefix sum example (O(n) pre-processing)
int[] prefix = new int[n + 1];

for (int i = 0;
 i < n;
 i++) {

    prefix[i + 1] = prefix[i] + arr[i];



}

// Range sum in O(1): prefix[r + 1] - prefix[l]

✅ Tip 2: Use ArrayList for Dynamic Resizing

In Java, ArrayList grows automatically and supports indexed access in O(1).

Prefer it over manual array resizing.

List<Integer> list = new ArrayList<>();

list.add(5);
 list.add(10);
 // Auto expands
System.out.println(list.get(1));
 // 10

✅ Tip 3: Use LinkedList When Frequent Insertions/Deletions Are Needed

LinkedList gives O(1) insertion/deletion at head/tail.

Avoid for indexed access (O(n) time).

Deque<Integer> dq = new LinkedList<>();

dq.addFirst(1);
 dq.addLast(2);
 dq.removeFirst();

✅ Tip 4: Understand HashMap for Frequency and Index Maps

Very common in CP – use for storing frequencies, positions, or visited states.

Map<Integer, Integer> freq = new HashMap<>();

for (int num : arr) freq.put(num, freq.getOrDefault(num, 0) + 1);

⚠️ Ensure that your keys are immutable and hashCode() is implemented correctly.

✅ Tip 5: Use TreeMap When Sorted Order Is Needed

TreeMap gives log(n) time complexity and auto-sorted keys.

Useful in interval scheduling, finding next/prev elements, or binary search replacements.

TreeMap<Integer, String> tm = new TreeMap<>();

tm.put(10, "A");
 tm.put(5, "B");
 tm.put(20, "C");

System.out.println(tm.higherKey(10));
 // 20

✅ Tip 6: HashSet for Constant-Time Lookup

Use HashSet when you want to quickly check existence without duplicates.

Common in problems like subarray sums, two-sum, or visited nodes.

Set<Integer> seen = new HashSet<>();

for (int num : arr) {

    if (seen.contains(target - num)) {

        return true;
 // Found a pair!
    

}

    seen.add(num);



}

✅ Tip 7: Deque for Sliding Window Optimization

Use Deque for max/min sliding windows.

Gives O(n) solution vs brute-force O(n*k).

// Max in sliding window of size k
Deque<Integer> dq = new ArrayDeque<>();

for (int i = 0;
 i < n;
 i++) {

    while (!dq.isEmpty() && dq.peekFirst() < i - k + 1) dq.pollFirst();

    while (!dq.isEmpty() && arr[dq.peekLast()] < arr[i]) dq.pollLast();

    dq.addLast(i);

    if (i >= k - 1) result.add(arr[dq.peekFirst()]);



}

✅ Tip 8: Two Pointers with Lists (Sorted Arrays)

Avoid nested loops using two-pointer pattern on sorted arrays/lists.

Best for sum problems, merging arrays, or in-place operations.

int l = 0, r = arr.length - 1;

while (l < r) {

    int sum = arr[l] + arr[r];

    if (sum == target) return true;

    else if (sum < target) l++;

    else r--;



}

✅ Tip 9: Matrix and 2D Arrays in CP

Grids are core in CP – pathfinding, DP, BFS, island problems.

Always use consistent direction arrays to move.

// 4-directional grid traversal
int[] dx = {
-1, 0, 1, 0

}
;

int[] dy = {
0, 1, 0, -1

}
;


for (int dir = 0;
 dir < 4;
 dir++) {

    int nx = x + dx[dir], ny = y + dy[dir];

    if (isValid(nx, ny)) {

        // proceed
    

}



}

✅ Tip 10: Efficient DP Arrays

Use 1D or rolling DP arrays for space optimization.

Always initialize arrays with correct base cases.

// Fibonacci DP with O(n) space
int[] dp = new int[n + 1];

dp[0] = 0;
 dp[1] = 1;

for (int i = 2;
 i <= n;
 i++) {

    dp[i] = dp[i - 1] + dp[i - 2];



}


// Rolling DP (space = 2)
int a = 0, b = 1, c = 0;

for (int i = 2;
 i <= n;
 i++) {

    c = a + b;

    a = b;
 b = c;



}

✅ Tip 11: Custom Sorting with Comparators

Java allows flexible custom sorting using Comparator. This is critical in contests for sorting based on multiple keys (e.g., descending frequency, ascending index).

// Sort 2D array by first col ASC, then second col DESC
Arrays.sort(arr, (a, b) -> {

    if (a[0] == b[0]) return b[1] - a[1];

    return a[0] - b[0];



}
);

✅ Tip 12: TreeMap / TreeSet for Ordered Access

For problems involving lower/upper bounds or maintaining a sorted structure dynamically, use TreeMap or TreeSet.

TreeSet<Integer> set = new TreeSet<>();

set.add(5);
 set.add(2);
 set.add(8);


System.out.println(set.floor(6));
 // 5
System.out.println(set.ceiling(6));
 // 8

✅ Tip 13: Frequency Maps and Multisets

Count elements using HashMap for frequency tracking or multiset simulation.

Map<Integer, Integer> freq = new HashMap<>();

for (int x : arr) {

    freq.put(x, freq.getOrDefault(x, 0) + 1);



}

Useful for problems like:

• Majority element
• Top K frequent
• Group anagrams

✅ Tip 14: Arrays.equals(), Arrays.fill() for Quick Setup

These utility methods are helpful when:

• Comparing full arrays in tests
• Filling base cases in DP

int[] dp = new int[n];

Arrays.fill(dp, -1);


if (Arrays.equals(arr1, arr2)) {

    // Do something


}

✅ Tip 15: Pitfalls in CP with Arrays

• ❌ Using Scanner for large input → use BufferedReader
• ❌ Modifying list while iterating → use Iterator.remove() or new list
• ❌ Comparing arrays with == → use Arrays.equals()
• ❌ Copying arrays with = → use Arrays.copyOf() or System.arraycopy()

✅ Practice converting CP solutions from C++ STL to Java Collections API!

🎯 Competitive Programming & DSA Perspective: Arrays & Collections (Part 1)

📦 1. Prefer Arrays Over Collections for CP Speed

Primitive arrays like int[] are much faster than ArrayList<Integer> due to no boxing/unboxing overhead.

// Faster
int[] arr = new int[100005];


// Slower due to boxing
ArrayList<Integer> list = new ArrayList<>();

Use Scanner or BufferedReader with int[] for optimal input.

📐 2. Constant-Time Lookup Using Arrays

Use arrays for frequency/counting to avoid HashMap overhead. Useful when elements are in a fixed range (e.g., 0–10⁶).

int[] freq = new int[1000001];

for (int num : arr) {

  freq[num]++;



}

🔄 Very efficient for counting sort or element frequency checks.

⚡ 3. Use Arrays.sort with Custom Comparator

Sorting arrays of objects or int[][] with a custom comparator is a common CP pattern.

// Sort by second column
Arrays.sort(arr, (a, b) -> Integer.compare(a[1], b[1]));

📊 Common in interval scheduling, greedy algorithms, and graph edges.

🔁 4. Two-Pointer Technique on Sorted Arrays

Two-pointer technique is highly efficient with arrays for problems like 2Sum, subarrays, and window sliding.

int l = 0, r = arr.length - 1;

while (l < r) {

  int sum = arr[l] + arr[r];

  if (sum == target) return true;

  else if (sum < target) l++;

  else r--;



}

🔄 5. Convert Arrays to Lists for Utility

You can convert arrays to lists using Arrays.asList() or Stream for quick use of collections functions like contains, indexOf, etc.

String[] words = {
"a", "b", "c"

}
;

List<String> list = Arrays.asList(words);

🧠 CP Tip: Use immutable conversions only for lookup or iteration. Arrays.asList() returns a fixed-size list, so no add() allowed!

🎯 Competitive Programming & DSA Perspective: Arrays & Collections (Part 2)

🔁 6. LinkedList in Competitive Programming

LinkedList offers O(1) insert/remove at head/tail. Ideal for queue, stack, or deque-based problems.

// Double-ended queue (deque)
LinkedList<Integer> dq = new LinkedList<>();

dq.addFirst(1);

dq.addLast(2);

dq.removeFirst();

✅ Best for problems like sliding window maximum, monotonic queue, undo-redo stack.

🔁 7. Use of Set to Remove Duplicates or Track Visits

HashSet is often used to detect cycles, store visited states, or ensure uniqueness.

// Check for duplicates
Set<Integer> seen = new HashSet<>();

for (int x : arr) {

  if (seen.contains(x)) return true;

  seen.add(x);



}

🔄 Also useful in backtracking problems to avoid recomputation.

⚙️ 8. Use of Map in Frequency or Count Problems

HashMap helps track frequency, counts, or even pair matching.

// Count frequencies
Map<Character, Integer> freq = new HashMap<>();

for (char c : s.toCharArray())
  freq.put(c, freq.getOrDefault(c, 0) + 1);

💡 9. Sorting with Custom Comparators in Java

Sort arrays or lists using Comparator when default order isn’t enough.

// Sort by 2nd element
Arrays.sort(pairs, (a, b) -> Integer.compare(a[1], b[1]));

🏁 Common in greedy, sweep line, and scheduling problems.

🎯 10. Avoiding TLE with Pre-Sized Maps and Lists

• Use new HashMap(initialCapacity) to avoid resizing during insert-heavy CP problems.
• Initialize ArrayList with capacity if number of inserts is known.

📌 11. Convert Between Structures in One Line

// Array to Set
Set<Integer> s = new HashSet<>(Arrays.asList(arr));

💡 Quick transformation saves time in implementation and readability.

⛓️ 12. TreeMap for Range Queries

// Nearest greater element
Map<Integer, Integer> map = new TreeMap<>();

((TreeMap) map).higherKey(k);

✅ Use TreeMap when frequency table needs sorted order or range navigation.

💾 13. ArrayDeque vs LinkedList

• ArrayDeque is faster than LinkedList for deque operations.
• Used in BFS, LRU simulation, or recent-item tracking.

🧠 14. Hashing + Sorting Combo

In some problems, use Map + Sort combo to group and process ordered keys.

// Frequency then sort by key
Map<Integer, Integer> map = new HashMap<>();

List<Integer> keys = new ArrayList<>(map.keySet());

Collections.sort(keys);

🔍 15. Reduce Memory with Primitive Arrays

In CP, prefer int[] or boolean[] over ArrayList<Integer> or HashSet for tight constraints.

✅ Summary: Understanding each collection's time and space complexity gives a significant edge in contests. Use the right structure based on operation frequency, size, and access pattern.

🎯 Competitive Programming & DSA Perspective: Exception Handling (Part 1)

🔍 Why Exception Handling Matters in CP?

In competitive programming, exception handling is rarely used for typical problem-solving due to performance concerns. However, understanding it is vital for:

• ⚠️ Handling edge input cases gracefully
• 🧪 Creating Fast I/O setups (e.g., catching I/O errors)
• 📚 In advanced mock interviews, where you build large systems with Java

✅ Tip #1: Avoid Runtime Exceptions by Input Checks

// ❌ Can cause ArrayIndexOutOfBoundsException
int[] arr = new int[5];

arr[5] = 100;
 // Out of bounds

// ✅ Better
if (i >= 0 && i < arr.length) arr[i] = 100;

✅ Tip #2: Use try-catch around Integer.parseInt() in real-world-style problems

// Good for simulation problems
try {

  int num = Integer.parseInt(str);



}
 catch (NumberFormatException e) {

  num = -1;
 // fallback logic


}

✅ Tip #3: Input Reading – Handle Unexpected Termination

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String line;

try {

  while ((line = br.readLine()) != null) {

    System.out.println("Input: " + line);

  

}



}
 catch (IOException e) {

  System.out.println("Input Error");



}

✅ Tip #4: Fast I/O in Java – Exception-Safe Template

class FastReader {

  BufferedReader br;

  StringTokenizer st;


  public FastReader() {

    br = new BufferedReader(new InputStreamReader(System.in));

  

}


  String next() {

    while (st == null || !st.hasMoreElements()) {

      try {

        st = new StringTokenizer(br.readLine());

      

}
 catch (IOException e) {

        return null;

      

}

    

}

    return st.nextToken();

  

}


  int nextInt() {
 return Integer.parseInt(next());
 

}



}

🧠 Why important? This structure ensures safe and efficient input parsing without crashing on I/O errors.

✅ Tip #5: Avoid Throwing Exceptions in Hot Paths

In CP, avoid unnecessary exception usage inside loops or recursion.

// ❌ DO NOT
for (int i = 0;
 i < 1_000_000;
 i++) {

  try {

    // risky call
  

}
 catch (Exception e) {


}



}

📉 This adds huge performance overhead.

✅ Tip #6: Use assert statements in debugging CP logic (optional)

int expected = 42;

assert computeResult() == expected : "Mismatch in expected logic";

📌 Helps in dry-run testing and internal validation in CP practice.

✅ Tip #7: Use Custom Exceptions in Simulation/OO CP Problems

class InvalidMoveException extends RuntimeException {


}


if (!isValidMove()) {

  throw new InvalidMoveException();



}

🎮 Useful in chess simulators, grid movement problems, etc.

🎯 Competitive Programming & DSA Perspective: Exception Handling (Part 2)

✅ Tip #8: Difference Between throw and throws in CP

throw is used to actually throw an exception instance.

throws is used to declare that a method might throw an exception.

// 🔽 Example
public static void riskyMethod() throws IOException {

  throw new IOException("File missing");



}

🚀 Rare in contests, but useful in simulation-type questions where structure matters.

✅ Tip #9: Recursive Exception Propagation (Memory-Efficient Abort)

Use exceptions for early termination in recursion-heavy simulations:

static class DoneException extends RuntimeException {


}


static void dfs(int u) {

  if (u == target) throw new DoneException();

  for (int v : adj[u]) dfs(v);



}


try {

  dfs(start);



}
 catch (DoneException e) {

  System.out.println("Found early!");



}

⚡ Stops deep recursive calls fast. Use carefully!

✅ Tip #10: Validate Inputs Without Exceptions in Hot Loops

// Instead of:
try {

  int val = Integer.parseInt(s);



}
 catch (Exception e) {


}


// Use:
boolean isNumeric = s.matches("\\d+");

if (isNumeric) {

  int val = Integer.parseInt(s);



}

🚫 Avoid exceptions for flow control. Use them only for truly exceptional cases.

✅ Tip #11: Use Exception StackTrace for Debugging Complex CP Logs

try {

  // risky logic


}
 catch (Exception e) {

  e.printStackTrace();



}

👀 Print stacktrace locally to debug segmentation-like issues or simulation breaks.

✅ Tip #12: Catch Exception in Development, SpecificException in Contest

In practice mode:

catch (Exception e) → broad coverage

In contests:

catch (IOException e), catch (ArithmeticException e) → lower overhead

✅ Tip #13: Prevent Crash on Div/0 or NullPointerException

try {

  int result = a / b;



}
 catch (ArithmeticException e) {

  System.out.println("Division by zero");



}

🔥 Can be helpful in grid or numeric simulations where values come from input.

✅ Tip #14: Handle Timeouts Gracefully (Useful in Java CP Platforms)

Some judges support timeouts or external task cancellation. Code should react properly.

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<?> future = executor.submit(() -> run());

try {

  future.get(2, TimeUnit.SECONDS);



}
 catch (TimeoutException e) {

  System.out.println("TLE!");



}

⏱️ Advanced use only – helpful in multi-threaded challenges.

✅ Tip #15: Use Exception as Soft Signal to End Simulation

class FinishedEarly extends RuntimeException {


}


public void simulate() {

  try {

    while (...) {

      if (finished) throw new FinishedEarly();

    

}

  

}
 catch (FinishedEarly e) {

    // Stop gracefully
  

}



}

📦 Helps in breaking nested loops in structured CP projects or mock system design rounds.

🎯 Competitive Programming & DSA Perspective: Java I/O

🚀 Why Fast I/O Matters in CP

In Competitive Programming (CP), the number of I/O operations can significantly impact your runtime.

• Standard Java I/O classes like Scanner and System.out.println are easy to use but slow for large datasets.
• To beat time limits, switch to BufferedReader and BufferedWriter, or create a custom FastReader.

✅ FastReader Class (Recap)

static class FastReader {

    BufferedReader br;

    StringTokenizer st;


    public FastReader() {

        br = new BufferedReader(new InputStreamReader(System.in));

    

}


    String next() {

        while (st == null || !st.hasMoreElements()) {

            try {
 st = new StringTokenizer(br.readLine());
 

}

            catch (IOException e) {
 e.printStackTrace();
 

}

        

}

        return st.nextToken();

    

}


    int nextInt() {
 return Integer.parseInt(next());
 

}

    long nextLong() {
 return Long.parseLong(next());
 

}

    double nextDouble() {
 return Double.parseDouble(next());
 

}

    String nextLine() {

        String str = "";

        try {
 str = br.readLine();
 

}

        catch (IOException e) {
 e.printStackTrace();
 

}

        return str;

    

}



}

💡 Tips & Tricks

1. Use BufferedReader for Input: Much faster than Scanner.
2. Avoid frequent flushing with BufferedWriter: Use .write() and flush once at the end.
3. Use StringBuilder for large outputs and print once.

📘 Example: Fast I/O CP Template

public class Main {

    public static void main(String[] args) throws IOException {

        FastReader sc = new FastReader();

        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));


        int t = sc.nextInt();

        while (t-- > 0) {

            int a = sc.nextInt();

            int b = sc.nextInt();

            out.write((a + b) + "\n");

        

}


        out.flush();
 // Flush once at the end
    

}



}

🎯 Competitive Use-Cases

• ⏱ Handling 10⁶+ inputs in time-limited contests
• 📂 Reading graphs, matrices, or ranges in bulk
• 💾 Reading from files in offline contests (ICPC-style)

📌 Strategy Summary

• Input: Prefer FastReader or BufferedReader over Scanner
• Output: Use BufferedWriter or StringBuilder + System.out.print
• Format carefully – avoid accidental whitespace issues

🏆 Benchmark

🎯 Competitive Programming & DSA Perspective – Java Threads

⚡ Why Learn Threads for CP?

While most online judges do not require threading, multithreading helps in:

• Handling large I/O asynchronously
• Performing parallel computations (e.g., prefix sums, merges)
• Creating efficient simulations (e.g., producer-consumer)

📘 Tip #1: Use Threads to Parallelize Independent Computation

You can speed up logic if the task can be broken into independent subtasks.

// Compute squares of 1000000 numbers using 4 threads
class SquareCalc implements Runnable {

    int[] arr;
 int start, end;

    SquareCalc(int[] arr, int start, int end) {

        this.arr = arr;
 this.start = start;
 this.end = end;

    

}

    public void run() {

        for (int i = start;
 i < end;
 i++) {

            arr[i] = arr[i] * arr[i];

        

}

    

}



}


public class Main {

    public static void main(String[] args) throws InterruptedException {

        int[] nums = new int[1000000];

        Arrays.fill(nums, 2);

        int chunk = nums.length / 4;


        Thread t1 = new Thread(new SquareCalc(nums, 0, chunk));

        Thread t2 = new Thread(new SquareCalc(nums, chunk, chunk * 2));

        Thread t3 = new Thread(new SquareCalc(nums, chunk * 2, chunk * 3));

        Thread t4 = new Thread(new SquareCalc(nums, chunk * 3, nums.length));


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

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


        System.out.println("Done computing squares.");

    

}



}

📘 Tip #2: Parallel Prefix Sum

Break array into chunks, compute local prefix, then adjust each chunk with the sum of previous chunks.

📘 Tip #3: Thread-Safe Counters (Atomic Variables)

AtomicInteger counter = new AtomicInteger(0);


Runnable task = () -> {

    for (int i = 0;
 i < 10000;
 i++) {

        counter.incrementAndGet();

    

}



}
;

✅ No need for synchronized, thread-safe by design.

📘 Tip #4: Producer-Consumer Pattern

Used in simulations and scheduling problems (e.g., job queue).

BlockingQueue queue = new ArrayBlockingQueue<>(5);


// Producer
new Thread(() -> {

    for (int i = 0;
 i < 10;
 i++) {

        queue.put(i);

        System.out.println("Produced: " + i);

    

}



}
).start();


// Consumer
new Thread(() -> {

    for (int i = 0;
 i < 10;
 i++) {

        int val = queue.take();

        System.out.println("Consumed: " + val);

    

}



}
).start();

📘 Tip #5: Timeout Handling

In CP simulations, use join(timeout) to prevent infinite wait:

Thread t = new Thread(task);

t.start();

t.join(1000);
 // Wait max 1s
if (t.isAlive()) {

    System.out.println("Timeout!");



}

🎯 Competitive Programming & DSA Perspective – Threads & Concurrency (Part 2)

📘 Tip #6: Fork/Join Framework for Divide & Conquer

Ideal for recursive tasks like merge sort, sum of elements, tree traversal.

Fork/Join parallelizes recursive calls using a work-stealing pool.

class SumTask extends RecursiveTask {

    long[] arr;
 int start, end;

    SumTask(long[] arr, int start, int end) {

        this.arr = arr;
 this.start = start;
 this.end = end;

    

}

    protected Long compute() {

        if (end - start <= 1000) {

            long sum = 0;

            for (int i = start;
 i < end;
 i++) sum += arr[i];

            return sum;

        

}

        int mid = (start + end) / 2;

        SumTask left = new SumTask(arr, start, mid);

        SumTask right = new SumTask(arr, mid, end);

        left.fork();

        long rightSum = right.compute();

        long leftSum = left.join();

        return leftSum + rightSum;

    

}



}


public class Main {

    public static void main(String[] args) {

        long[] nums = new long[1_000_000];

        Arrays.fill(nums, 1);

        ForkJoinPool pool = new ForkJoinPool();

        long result = pool.invoke(new SumTask(nums, 0, nums.length));

        System.out.println("Sum: " + result);

    

}



}

📘 Tip #7: Multi-threaded Prime Number Check

Useful for parallelizing brute-force search of primes in a range.

class PrimeChecker extends Thread {

    int start, end;

    PrimeChecker(int start, int end) {

        this.start = start;
 this.end = end;

    

}

    public void run() {

        for (int i = start;
 i <= end;
 i++) {

            if (isPrime(i)) System.out.println(i + " is prime");

        

}

    

}

    boolean isPrime(int n) {

        if (n < 2) return false;

        for (int i = 2;
 i * i <= n;
 i++)
            if (n % i == 0) return false;

        return true;

    

}



}

public class Main {

    public static void main(String[] args) {

        new PrimeChecker(2, 5000).start();

        new PrimeChecker(5001, 10000).start();

    

}



}

📘 Tip #8: File-Based Threading Simulation

For simulating real-world scenarios like log parsing, file downloads, etc.

class FileProcessor extends Thread {

    private String fileName;

    FileProcessor(String fileName) {
 this.fileName = fileName;
 

}

    public void run() {

        try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {

            String line;

            while ((line = br.readLine()) != null) {

                // Simulate parsing
                System.out.println("[" + fileName + "] " + line);

            

}

        

}
 catch (IOException e) {

            System.out.println("Error reading: " + fileName);

        

}

    

}



}

public class Main {

    public static void main(String[] args) {

        new FileProcessor("file1.txt").start();

        new FileProcessor("file2.txt").start();

    

}



}

✅ File-based threading is also a useful simulation pattern for multi-source input processing in project backends and Java-based utilities.

🎯 Competitive Programming & DSA Perspective: Inner Classes, Anonymous Classes, Lambdas (Part 1)

Tip 1: Compact Comparators Using Lambdas

Competitive Programming sometimes requires sorting based on custom rules. Lambdas let you quickly define a comparator inline:

List<int[]> points = new ArrayList<>();

points.add(new int[]{
3, 4

}
);

points.add(new int[]{
1, 2

}
);


points.sort((a, b) -> a[0] - b[0]);
 // Sort by first element

This is faster to type and helps in contests where brevity and accuracy matter. In traditional Java, you'd need to create a full comparator class or anonymous class.

Tip 2: Encapsulating Strategy with Inner Classes

When you want to simulate different strategies or stateful helpers during recursion/DFS/BFS, inner classes help avoid clutter:

class GraphSolver {

    class DFS {

        boolean[] visited;

        void run(int node) {

            visited[node] = true;

            for (int neighbor : adj[node]) {

                if (!visited[neighbor]) run(neighbor);

            

}

        

}

    

}



}

Encapsulating DFS in an inner class avoids leaking `visited[]` or state outside and prevents global variable usage.

Tip 3: Anonymous Classes for On-the-Fly Listeners

For coding games or event-driven simulations (e.g., Grid-based games or Turing machines), you can use anonymous classes:

EventListener listener = new EventListener() {

    public void onClick(int x, int y) {

        System.out.println("Clicked at " + x + "," + y);

    

}



}
;

Though not common in pure CP, this is useful in GUI-based contest problems or Java-based simulation rounds.

Tip 4: Using Lambdas for Filtering and Mapping

While CP generally avoids stream APIs due to performance, Lambdas are handy for filtering in debugging or system-based tasks:

List<Integer> odds = arr.stream()
                        .filter(x -> x % 2 != 0)
                        .collect(Collectors.toList());

Though slower than manual loops in CP, such usage helps in quick data filtering during problem exploration or pre/post-processing.

Tip 5: Closures with Lambdas

Lambdas can capture variables (effectively final), which helps in memoization setups:

Map<Integer, Integer> memo = new HashMap<>();

Function<Integer, Integer> fib = n -> {

    if (n <= 1) return n;

    return memo.computeIfAbsent(n, k -> fib.apply(k - 1) + fib.apply(k - 2));



}
;

Here, memo is accessible inside lambda. This mimics top-down DP with memoization elegantly.

🎯 Competitive Programming & DSA Perspective: Inner Classes, Anonymous Classes, Lambdas (Part 2)

Tip 6: Sorting with Lambdas in Contests

Lambdas are extremely powerful for quick sorting with custom rules, such as sorting a list of pairs by value then by index:

List<int[]> list = new ArrayList<>();

list.add(new int[]{
5, 1

}
);

list.add(new int[]{
3, 2

}
);

list.add(new int[]{
5, 0

}
);


list.sort((a, b) -> a[0] != b[0] ? b[0] - a[0] : a[1] - b[1]);

// Sort descending by value, ascending by index

Fast and concise. No need to write bulky Comparator classes in the middle of a timed contest.

Tip 7: Combining Comparator Chains

You can chain multiple sorting conditions elegantly:

list.sort(Comparator
    .comparingInt((int[] a) -> a[0])           // primary
    .thenComparingInt(a -> a[1])               // secondary
);

This makes sorting logic highly readable even when using multiple levels of comparison. Great for sorting intervals, tuples, custom objects, etc.

Tip 8: Nested Inner Classes for DSU (Disjoint Set Union)

Using inner classes helps encapsulate union-find logic and avoids global arrays:

class DSU {

    private int[] parent, rank;

    DSU(int n) {

        parent = new int[n];

        rank = new int[n];

        for (int i = 0;
 i < n;
 i++) parent[i] = i;

    

}


    int find(int x) {

        if (parent[x] != x)
            parent[x] = find(parent[x]);

        return parent[x];

    

}


    void union(int x, int y) {

        int rx = find(x), ry = find(y);

        if (rx == ry) return;

        if (rank[rx] < rank[ry]) parent[rx] = ry;

        else if (rank[rx] > rank[ry]) parent[ry] = rx;

        else {
 parent[ry] = rx;
 rank[rx]++;
 

}

    

}



}

Organizing DSU logic inside a class lets you reuse the code cleanly across multiple CP problems like Kruskal's MST, Connected Components, etc.

Tip 9: Lambdas in Graph Algorithms (Weighted DFS)

In advanced CP, lambdas can define recursive DFS or function graphs dynamically:

Map<Integer, List<Integer>> graph = new HashMap<>();

Set<Integer> visited = new HashSet<>();


Consumer<Integer> dfs = new Consumer<>() {

    public void accept(Integer u) {

        visited.add(u);

        for (int v : graph.getOrDefault(u, new ArrayList<>()))
            if (!visited.contains(v)) accept(v);

    

}



}
;

dfs.accept(0);

Though a bit verbose, it's an elegant way to inline recursive logic with closure-style context handling.

Tip 10: Lambdas in Segment Tree Construction (Custom Merges)

Sometimes you need different merge logic for sum, min, max, or custom queries. Lambdas allow plug-and-play design:

class SegmentTree {

    int[] tree;

    int n;

    BiFunction<Integer, Integer, Integer> merger;


    SegmentTree(int[] arr, BiFunction<Integer, Integer, Integer> merger) {

        this.n = arr.length;

        this.tree = new int[4 * n];

        this.merger = merger;

        build(arr, 0, 0, n - 1);

    

}


    void build(int[] arr, int idx, int l, int r) {

        if (l == r) tree[idx] = arr[l];

        else {

            int m = (l + r) / 2;

            build(arr, 2 * idx + 1, l, m);

            build(arr, 2 * idx + 2, m + 1, r);

            tree[idx] = merger.apply(tree[2 * idx + 1], tree[2 * idx + 2]);

        

}

    

}



}

Usage:

SegmentTree st = new SegmentTree(arr, (a, b) -> Math.max(a, b));

This gives you full flexibility in designing segment trees in a CP-friendly reusable way.

🎯 CP & DSA Perspective: Inner Classes, Anonymous Classes, Lambdas (Part 3)

Tip 11: Lambdas in Multi-threaded CP Simulation

For advanced simulations (like parallel queue processing, bank systems, scheduler emulators), lambdas help inject logic into threads dynamically:

Runnable task = () -> {

    for (int i = 0;
 i < 5;
 i++) {

        System.out.println("Thread: " + Thread.currentThread().getName() + " i=" + i);

    

}



}
;


Thread t1 = new Thread(task);

Thread t2 = new Thread(task);

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

Perfect for simulating parallel events or distributed tasks with less boilerplate. Combine with `ExecutorService` for scalability.

Tip 12: Lambdas for Backtracking/GREEDY Tree Exploration

Lambdas simplify recursive call tracking and branching in decision trees:

Function<int[], Boolean> canPartition = new Function<>() {

    boolean dfs(int i, int[] nums, int sum1, int sum2) {

        if (i == nums.length) return sum1 == sum2;

        return dfs(i+1, nums, sum1 + nums[i], sum2) || dfs(i+1, nums, sum1, sum2 + nums[i]);

    

}

    public Boolean apply(int[] nums) {

        return dfs(0, nums, 0, 0);

    

}



}
;

Enables clear backtracking logic while allowing function encapsulation for reuse or parameter tweaking.

Tip 13: CP-Style Event Loops with Lambdas or Inner Classes

Inner classes and lambdas help implement event-driven simulation loops (for problems like OS task scheduling, auction, or timeline simulation):

class EventSimulator {

    static class Event {

        int time;

        Runnable action;

        Event(int time, Runnable action) {

            this.time = time;

            this.action = action;

        

}

    

}


    public static void main(String[] args) {

        PriorityQueue<Event> pq = new PriorityQueue<>(Comparator.comparingInt(e -> e.time));

        pq.add(new Event(1, () -> System.out.println("Fetch item")));

        pq.add(new Event(3, () -> System.out.println("Process result")));

        pq.add(new Event(2, () -> System.out.println("Send request")));


        while (!pq.isEmpty()) {

            Event e = pq.poll();

            e.action.run();

        

}

    

}



}

Simple and powerful pattern for simulating discrete time systems or multi-phase logic in contests.

Final Tip 14: Use lambdas for reducing verbose code under time pressure

Anything from comparators to predicates and loop operations becomes cleaner and faster to write with lambdas:

// Traditional way
Collections.sort(list, new Comparator<Integer>() {

    public int compare(Integer a, Integer b) {

        return b - a;

    

}



}
);


// Lambda
list.sort((a, b) -> b - a);

Tip 15: Combine Inner Class + Lambda for Custom Structures

Example: Segment Tree with lambda-based merge and update strategies:

class CustomSegmentTree {

    int[] tree;

    BiFunction<Integer, Integer, Integer> merge;


    CustomSegmentTree(int[] arr, BiFunction<Integer, Integer, Integer> merge) {

        this.merge = merge;

        // ...
    

}


    void update(int idx, int val) {

        // merge logic using lambda
    

}



}

Perfect for abstracting multiple data structure behaviors (min, max, GCD, sum) with one codebase.

🎯 Competitive Programming & DSA Perspective: Memory-Efficient Code – Part 1

1. Use Primitive Types Instead of Objects

In tight memory environments like coding contests, prefer primitive types (int, long) over boxed types (Integer, Long) to reduce heap usage.

// Bad
List<Integer> list = new ArrayList<>();

for (int i = 0;
 i < 1000000;
 i++) list.add(i);


// Good
int[] arr = new int[1000000];

for (int i = 0;
 i < 1000000;
 i++) arr[i] = i;

Why? Integer uses extra memory due to object headers and reference indirection. Avoid unless needed.

2. Memory-Efficient 2D Structures

Instead of using int[][], flatten the matrix into a 1D array:

// Instead of int[][] grid = new int[1000][1000];

int[] grid = new int[1000 * 1000];

int get(int x, int y) {
 return grid[x * 1000 + y];
 

}

void set(int x, int y, int val) {
 grid[x * 1000 + y] = val;
 

}

When to Use? For DP, image processing, matrix problems — saves space, better cache locality.

3. Avoid Recursion if Stack Overflow is a Risk

Replace deep recursive DFS with iterative stack-based version for large inputs.

// Recursion may cause StackOverflow
void dfs(int u) {

  visited[u] = true;

  for (int v : adj[u])
    if (!visited[v]) dfs(v);



}


// Iterative DFS
Stack<Integer> stack = new Stack<>();

stack.push(start);

while (!stack.isEmpty()) {

  int u = stack.pop();

  if (visited[u]) continue;

  visited[u] = true;

  for (int v : adj[u])
    if (!visited[v]) stack.push(v);



}

Tip: Stack has 512KB–1MB limits in most CP judges. Iterative solutions avoid that bottleneck.

🎯 Competitive Programming & DSA Perspective: Memory-Efficient Code – Part 2

4. Reuse Objects and Collections When Possible

In time-limited and memory-constrained contests, constant object reallocation slows down GC and wastes memory. Reuse arrays or lists by clearing instead of recreating.

// Bad: Reallocates list in every test case
List<Integer> list = new ArrayList<>();

list = new ArrayList<>();
 // GC may lag behind

// Good: Reuse same list
list.clear();
 // Retains memory, faster for multiple test cases

Tip: Use Arrays.fill() to reset arrays instead of reallocation. Faster and cleaner for reuse.

5. Use BitSet or Bit Masking for Boolean Arrays

To mark boolean flags efficiently (e.g., visited[], sieve of Eratosthenes), prefer using BitSet or bit manipulation over boolean[].

// Bit masking: 8 flags in one byte
int flags = 0;

flags |= (1 << 3);
 // Set 3rd bit
boolean isSet = (flags & (1 << 3)) != 0;


// BitSet alternative
BitSet bs = new BitSet(1000000);

bs.set(10);

bs.get(10);
 // true

Why? Bit-based storage uses 8x less memory than boolean[] and is cache-friendly in large arrays.

6. Avoid Object Arrays When Not Needed

Prefer int[] over Integer[], char[] over Character[], etc. Object wrappers add memory overhead and slow GC.

// Avoid
Integer[] data = new Integer[100000];


// Prefer
int[] data = new int[100000];

When? Always default to primitives unless nulls or boxed behaviors (like in Collections) are required.

🎯 Competitive Programming & DSA Perspective: Memory-Efficient Code – Part 3

7. Prefer ArrayDeque Over Stack or LinkedList

Why? Java's Stack is synchronized (slower) and LinkedList has more memory overhead per node due to object headers and pointers. Use ArrayDeque for faster and memory-friendly stack/queue behavior.

// Old style
Stack<Integer> stack = new Stack<>();


// Better
Deque<Integer> stack = new ArrayDeque<>();

stack.push(1);

stack.pop();

Bonus: Use ArrayDeque for BFS/DFS with both addFirst and addLast operations.

8. Memory-Safe Segment Trees

Segment Trees are memory-heavy: int[4*n] for arrays of size n. You can reduce space with:

• Lazy trees – allocate only when needed (e.g., TreeMap-based segment trees)
• In-place updates – only keep minimum nodes (especially in sparse cases)

// Standard segment tree size
int[] seg = new int[4 * n];
 // Safe bound

// Sparse tree: only when needed
TreeMap<Integer, Integer> tree = new TreeMap<>();
 // Useful in dynamic range queries

Tip: Avoid unnecessary arrays for queries like RMQ, Kth max using techniques like Sparse Table or Fenwick Tree which are smaller.

9. Trie vs HashMap: Space Trade-Offs

Tries can consume lots of memory when branching factor is high. Use compressed tries or Ternary Search Trees for space efficiency. Use HashMap<Character, Node> only when keys are sparse.

// Naive trie node
class Node {

  Node[] next = new Node[26];
 // 26 pointers = high memory


}


// Compressed alternative (only create needed edges)
class Node {

  Map<Character, Node> map = new HashMap<>();
 // Better for sparse words


}

Memory Hint: Use shared suffix structures or rolling hashes when memory is tight (e.g., string deduplication).

🎯 Competitive Programming & DSA Perspective: Memory-Efficient Code – Part 4

10. Prefer Primitive Heaps Over Java's PriorityQueue

Java’s PriorityQueue stores Integer (boxed type) → adds memory overhead. In tight constraints, implement your own min/max heap using arrays.

// Java PQ - extra boxing overhead
PriorityQueue<Integer> pq = new PriorityQueue<>();


// Fast primitive min-heap
int[] heap = new int[n];

int size = 0;

void push(int x) {

    heap[size++] = x;

    // heapify-up manually


}

Tip: CP libraries like KACTL use in-place binary heaps with O(1) memory overhead.

11. Use Object Pooling in Repetitive Simulations

Instead of allocating new objects repeatedly, reuse instances via pooling (especially in graph problems or simulations).

class NodePool {

    Node[] pool;

    int idx = 0;


    NodePool(int size) {

        pool = new Node[size];

        for (int i = 0;
 i < size;
 i++) pool[i] = new Node();

    

}


    Node get() {

        return pool[idx++];

    

}



}

Where Useful: Simulated Annealing, Genetic Algorithms, Grid simulations with 100k+ operations.

12. Apply Compression Techniques (Coordinate + Bit)

• Coordinate Compression: Reduce range of input (e.g., large values) to smaller indices for array storage
• Bit Compression: Use bitmasks to represent states instead of boolean arrays

// Coordinate Compression
Set<Integer> set = new TreeSet<>();

for (int x : arr) set.add(x);

Map<Integer, Integer> compressed = new HashMap<>();

int id = 0;

for (int x : set) compressed.put(x, id++);


// Bitmask Compression
// Instead of boolean[10]
int state = 0b0000000000;

state |= (1 << 3);
 // turn on bit 3
state &= ~(1 << 3);
 // turn off bit 3

Use in: DP states, Graph coloring, Subset enumeration.

✅ Summary: Competitive Programming – Memory-Efficient Java Tricks

Use this checklist during contests when memory usage is a concern (tight limits like 256MB or 512MB):

1. Prefer Primitive Types: Use int, long, boolean instead of boxed classes like Integer, Long. Avoid List<Integer> unless necessary.



2. Flatten 2D Structures: Replace int[][] with int[] using manual indexing arr[x * cols + y].



3. Convert Deep Recursion: Rewrite DFS/DP to iterative stack-based versions to avoid stack overflow.



4. Avoid Object Arrays: Instead of Node[] use pooled or shared data structures when possible.



5. Clear Large Structures: Nullify or .clear() large objects after use to allow GC.



6. Avoid Strings in Hot Paths: Use char[] or StringBuilder in performance sections.



7. Avoid Java PriorityQueue if Possible: Use primitive heaps or simulate with int[].



8. Object Pooling: Reuse frequently constructed objects like nodes in graphs/simulations.



9. Bitmask Compression: Represent boolean arrays or state maps with integers/bitmasks.



10. Coordinate Compression: Reduce large values (e.g., [10^9]) to dense indices (e.g., [0..n]) for array access.

Final Tip: In high-memory constraints, avoid abstract libraries or unnecessary object wrappers. Stick to low-level structures like arrays, simple loops, and tight loops.

🎯 Competitive Programming & DSA Perspective: Generics – Part 1

1. Generic Stack, Queue, and Tree Implementations

Using generics in custom DSA structures avoids rewriting similar code for different data types and improves clarity.

// Generic Stack class Stack<T> {
 private LinkedList<T> list = new LinkedList<>();
 void push(T val) {
 list.addFirst(val);
 

}
 T pop() {
 return list.removeFirst();
 

}
 T peek() {
 return list.getFirst();
 

}
 boolean isEmpty() {
 return list.isEmpty();
 

}
 

}
 

// Usage Stack<Integer> intStack = new Stack<>();
 Stack<String> strStack = new Stack<>();
 

Benefit: Type-safe, clean DSA structures — no casting, reuse across problems involving various types (int, char[], Point, etc.).