Beginner

// File: HelloWorld.java (filename must match public class name)
public class HelloWorld {                          // => Public class, accessible from other packages
    public static void main(String[] args) {       // => Entry point: public static void main(String[])
        System.out.println("Hello, World!");       // => Output: Hello, World!
    }                                              // => println adds newline after text
}

// Compilation: javac HelloWorld.java → HelloWorld.class (bytecode)
// => javac compiles .java source to platform-independent .class bytecode
// Execution: java HelloWorld → JVM loads .class and runs main()
// => Same .class file runs on Windows, Linux, macOS (write once, run anywhere)

// PRIMITIVE TYPES (8 total, stored on stack, cannot be null)
byte b = 127;                    // => 8-bit signed integer, range: -128 to 127
short s = 32000;                 // => 16-bit signed integer, range: -32,768 to 32,767
int i = 42;                      // => 32-bit signed integer (DEFAULT for whole numbers)
long l = 1000000L;               // => 64-bit signed integer, requires L suffix
float f = 3.14f;                 // => 32-bit floating-point, requires f suffix
double d = 3.14159;              // => 64-bit floating-point (DEFAULT for decimals)
boolean bool = true;             // => true or false (NOT 0/1 like C)
char c = 'A';                    // => 16-bit Unicode character (single quotes only)

// REFERENCE TYPES (stored on heap, can be null)
String str = "Hello";            // => Reference to String object in heap
                                 // => Literal "Hello" stored in string pool (shared memory)
int[] array = {1, 2, 3};         // => Reference to array object, array.length is 3

// TYPE INFERENCE with var (Java 10+, local variables only)
var num = 100;                   // => Type inferred as int at compile time
var text = "World";              // => Type inferred as String (still statically typed)

System.out.println(i);           // => Output: 42
System.out.println(str);         // => Output: Hello

import java.util.Scanner;        // => Scanner from java.util (not auto-imported)

Scanner scanner = new Scanner(System.in);
// => scanner wraps System.in (console input stream)
// => Provides type-safe parsing methods (nextInt, nextDouble, nextLine)

System.out.print("Enter your name: ");
// => print() does NOT add newline (cursor stays on same line)
String name = scanner.nextLine(); // => Reads entire line until Enter (\n)
                                  // => Input: "Alice" → name is "Alice"

System.out.print("Enter your age: ");
int age = scanner.nextInt();     // => Reads next integer token
                                 // => Input: 25 → age is 25
scanner.nextLine();              // => Consume leftover newline after nextInt()

System.out.println("Hello, " + name + "! You are " + age + " years old.");
// => Output: Hello, Alice! You are 25 years old.

scanner.close();                 // => Close scanner to release resources
                                 // => Also closes underlying System.in stream

int score = 85;

// IF/ELSE - traditional conditional
if (score >= 90) {               // => Condition is false (85 < 90)
    System.out.println("Grade: A");
} else if (score >= 80) {        // => Condition is true (85 >= 80)
    System.out.println("Grade: B");
    // => Output: Grade: B (execution stops after first true branch)
} else if (score >= 70) {        // => Skipped (previous branch executed)
    System.out.println("Grade: C");
} else {                         // => Skipped
    System.out.println("Grade: F");
}

// SWITCH STATEMENT - multi-way branch (traditional, Java 1.0+)
String day = "Monday";
switch (day) {                   // => Switch on String (Java 7+)
    case "Monday":               // => Matches (day equals "Monday")
        System.out.println("Start of work week");
        break;                   // => Exit switch (without break, falls through!)
        // => Output: Start of work week
    case "Friday":               // => Skipped (Monday already matched)
        System.out.println("TGIF!");
        break;
    default:                     // => Skipped
        System.out.println("Midweek");
}

// SWITCH EXPRESSION - modern syntax (Java 14+)
int numLetters = switch (day) {  // => Switch as expression (returns value)
    case "Monday", "Friday" -> 6; // => Arrow syntax (no fall-through)
    case "Tuesday" -> 7;
    case "Wednesday" -> 9;
    default -> 0;
};
// => numLetters is 6 ("Monday" has 6 letters)
System.out.println(numLetters);  // => Output: 6

// FOR LOOP - known iteration count
for (int i = 0; i < 5; i++) {    // => i starts at 0, increments until i < 5 is false
                                 // => Loop structure: init; condition; increment
    System.out.print(i + " ");   // => i is 0, 1, 2, 3, 4 (5 iterations total)
                                 // => Each iteration prints i followed by space
}                                // => Output: 0 1 2 3 4
System.out.println();            // => Newline after loop (moves cursor to next line)

// WHILE LOOP - condition-checked before each iteration
int count = 0;                   // => count initialized to 0
while (count < 3) {              // => Check condition first (may execute 0 times if false)
                                 // => Loop continues while count < 3
    System.out.print(count + " ");
                                 // => Prints current value followed by space
    count++;                     // => Increment count (count becomes 1, 2, 3)
                                 // => After count becomes 3, condition fails, loop exits
}                                // => Output: 0 1 2 (three iterations)
System.out.println();            // => Newline after loop

// DO-WHILE LOOP - condition-checked after each iteration
int num = 0;                     // => num initialized to 0 (starting value)
do {                             // => Execute body first (always runs at least once)
                                 // => Guarantees minimum one iteration even if condition false initially
    System.out.print(num + " ");
                                 // => First iteration: num is 0, prints "0 "
                                 // => Second iteration: num is 1, prints "1 "
                                 // => Third iteration: num is 2, prints "2 "
    num++;                       // => Increment after printing (num becomes 1, 2, 3)
                                 // => Post-increment ensures printed value is original
} while (num < 3);               // => Check condition after execution (runs after num becomes 3)
                                 // => Condition false (3 < 3 is false), loop exits
                                 // => Output: 0 1 2 (three iterations executed)
System.out.println();            // => Newline after loop completes

// ENHANCED FOR LOOP - iterate over arrays/collections
int[] numbers = {10, 20, 30};    // => Array with 3 elements stored contiguously
                                 // => numbers.length is 3 (array property)
for (int n : numbers) {          // => "for each n in numbers" (enhanced for-loop syntax)
                                 // => Compiler generates iterator code automatically
                                 // => First iteration: n = numbers[0] = 10
                                 // => Second iteration: n = numbers[1] = 20
                                 // => Third iteration: n = numbers[2] = 30
    System.out.print(n + " ");   // => Prints current element followed by space
                                 // => No manual index management (no i++, no array[i])
}                                // => Output: 10 20 30 (all elements printed)
                                 // => Loop terminates automatically after last element

// ARRAY DECLARATION AND INITIALIZATION
int[] numbers = {1, 2, 3, 4, 5}; // => Inline initialization (size inferred)
                                 // => numbers.length is 5 (property, not method!)
int[] empty = new int[10];       // => Allocates 10 elements, all initialized to 0
                                 // => Default values: 0 for int, false for boolean, null for objects

// ARRAY ACCESS
int first = numbers[0];          // => first is 1 (arrays are 0-indexed)
int last = numbers[numbers.length - 1];
                                 // => last is 5 (length-1 gets last element)
numbers[2] = 99;                 // => numbers is now {1, 2, 99, 4, 5}

// ARRAY UTILITIES (java.util.Arrays)
import java.util.Arrays;

int[] copy = Arrays.copyOf(numbers, numbers.length);
                                 // => Creates deep copy of numbers array
String str = Arrays.toString(numbers);
                                 // => str is "[1, 2, 99, 4, 5]" (readable string representation)
Arrays.sort(numbers);            // => Sorts in-place: numbers becomes {1, 2, 4, 5, 99}

// MULTIDIMENSIONAL ARRAYS
int[][] matrix = {               // => 2D array (array of arrays)
    {1, 2, 3},
    {4, 5, 6}
};
int value = matrix[1][2];        // => value is 6 (row 1, column 2)

// CLASS DEFINITION
public class Person {            // => Blueprint for Person objects
    // FIELDS (instance variables, state)
    String name;                 // => Each Person object has its own name field
    int age;                     // => Default: null for String, 0 for int

    // CONSTRUCTOR - special method to initialize new objects
    public Person(String name, int age) {
                                 // => Called when: new Person("Alice", 30)
        this.name = name;        // => this.name refers to instance field, name refers to parameter
        this.age = age;          // => Assigns parameter value to instance field
    }

    // METHOD - defines behavior
    public void introduce() {    // => void = no return value
        System.out.println("Hi, I'm " + name + " and I'm " + age + " years old.");
        // => Can access instance fields directly (name, age implicitly refer to this.name, this.age)
    }
}

// CREATING OBJECTS (instantiation)
Person alice = new Person("Alice", 30);
                                 // => new keyword allocates memory on heap for Person object
                                 // => Calls Person constructor with arguments "Alice", 30
                                 // => alice variable stores reference (memory address) to object
                                 // => Object has independent state: alice.name="Alice", alice.age=30
Person bob = new Person("Bob", 25);
                                 // => Separate object with different state
                                 // => bob.name="Bob", bob.age=25 (independent from alice)

// CALLING METHODS
alice.introduce();               // => Output: Hi, I'm Alice and I'm 30 years old.
bob.introduce();                 // => Output: Hi, I'm Bob and I'm 25 years old.

// FIELD ACCESS
System.out.println(alice.name);  // => Output: Alice (direct field access)

// SUPERCLASS (base class, parent class)
class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// SUBCLASS (derived class, child class)
class Dog extends Animal {       // => Dog inherits all fields/methods from Animal
    @Override                    // => Annotation: indicates intentional method override
    public void makeSound() {    // => Overrides Animal's makeSound()
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// POLYMORPHISM - treating specific types through general type
Animal animal1 = new Dog();      // => Dog object referenced as Animal (upcast)
Animal animal2 = new Cat();      // => Cat object referenced as Animal
animal1.makeSound();             // => Output: Woof! (Dog's method called, not Animal's)
animal2.makeSound();             // => Output: Meow! (runtime polymorphism)

// ARRAY OF POLYMORPHIC OBJECTS
Animal[] animals = {new Dog(), new Cat(), new Dog()};
for (Animal a : animals) {       // => Iterate using Animal type
    a.makeSound();               // => Calls correct subclass method for each object
}                                // => Output: Woof! Meow! Woof!

// INTERFACE DEFINITION
public interface Drawable {      // => Contract: any Drawable must implement draw()
    void draw();                 // => Abstract method (no body, implicitly public abstract)
    // => Constants are implicitly public static final
    double PI = 3.14159;         // => Accessible as Drawable.PI
}

// CLASS IMPLEMENTING INTERFACE
class Circle implements Drawable {
                                 // => Circle must implement all Drawable methods
    @Override
    public void draw() {         // => Must be public (interface methods are public)
        System.out.println("Drawing a circle");
    }
}

class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

// MULTIPLE INTERFACE IMPLEMENTATION
interface Resizable {
    void resize(int factor);
}

class FlexibleCircle implements Drawable, Resizable {
                                 // => Can implement multiple interfaces (no multiple inheritance for classes)
    @Override
    public void draw() {
        System.out.println("Drawing flexible circle");
    }

    @Override
    public void resize(int factor) {
        System.out.println("Resizing by " + factor);
    }
}

// POLYMORPHISM WITH INTERFACES
Drawable shape1 = new Circle(); // => Circle referenced as Drawable
Drawable shape2 = new Square();
shape1.draw();                   // => Output: Drawing a circle
shape2.draw();                   // => Output: Drawing a square

import java.util.ArrayList;

// CREATE ArrayList
ArrayList<String> names = new ArrayList<>();
                                 // => Generic type <String> specifies element type at compile time
                                 // => Initially empty with default capacity 10
                                 // => Internal array grows automatically when capacity exceeded

// ADD ELEMENTS
names.add("Alice");              // => Appends to end at index 0
                                 // => Internal array: ["Alice", null, null, ..., null]
                                 // => names is ["Alice"], size is 1
names.add("Bob");                // => Appends at index 1 (next available position)
                                 // => Internal array: ["Alice", "Bob", null, ..., null]
                                 // => names is ["Alice", "Bob"], size is 2
names.add(1, "Charlie");         // => Insert at index 1, shifts Bob to index 2
                                 // => Shifts existing elements right to make space
                                 // => Internal array: ["Alice", "Charlie", "Bob", null, ..., null]
                                 // => names is ["Alice", "Charlie", "Bob"], size is 3

// ACCESS ELEMENTS
String first = names.get(0);     // => first is "Alice" (0-indexed like arrays)
int size = names.size();         // => size is 3 (method, not property like array.length)

// MODIFY ELEMENTS
names.set(2, "Dave");            // => Replace element at index 2
                                 // => names is ["Alice", "Charlie", "Dave"] (Bob replaced)

// REMOVE ELEMENTS
names.remove("Charlie");         // => Remove by value (searches for "Charlie")
                                 // => Linear search O(n) through array to find "Charlie"
                                 // => Found at index 1, removes element
                                 // => Shifts remaining elements left to fill gap
                                 // => names is ["Alice", "Dave"], size is 2
names.remove(0);                 // => Remove by index (removes first element)
                                 // => Removes "Alice" at index 0
                                 // => Shifts "Dave" from index 1 to index 0
                                 // => names is ["Dave"], size is 1

// ITERATE
for (String name : names) {      // => Enhanced for-loop works with ArrayList
    System.out.println(name);    // => Output: Dave
}

// CONTAINS AND SEARCH
boolean has = names.contains("Dave");
                                 // => has is true (linear search O(n))
int index = names.indexOf("Dave");
                                 // => index is 0 (returns -1 if not found)

import java.util.HashMap;
import java.util.Map;

// CREATE HashMap
HashMap<String, Integer> ages = new HashMap<>();
                                 // => Key type: String, Value type: Integer
                                 // => Backed by hash table (array + linked lists/trees)

// PUT key-value pairs
ages.put("Alice", 30);           // => Computes hash of "Alice" key using hashCode()
                                 // => Maps hash to bucket index: hash % array.length
                                 // => Stores Entry("Alice", 30) at computed bucket
                                 // => ages is {"Alice": 30}, size is 1
ages.put("Bob", 25);             // => Computes hash of "Bob", maps to bucket index
                                 // => Different hash likely results in different bucket
                                 // => Stores Entry("Bob", 25) at its bucket
                                 // => ages is {"Alice": 30, "Bob": 25}, size is 2
ages.put("Alice", 31);           // => Computes hash of "Alice" (same as before)
                                 // => Finds existing Entry with key "Alice" in bucket
                                 // => Overwrites old value 30 with new value 31
                                 // => ages is {"Alice": 31, "Bob": 25}, size still 2

// GET values by key
int aliceAge = ages.get("Alice");// => Computes hash of "Alice", looks up bucket
                                 // => aliceAge is 31 (value found)
Integer charlieAge = ages.get("Charlie");
                                 // => Computes hash, looks up bucket, key not found
                                 // => charlieAge is null (key doesn't exist, returns null)

// GET with default value (Java 8+)
int defaultAge = ages.getOrDefault("Charlie", 0);
                                 // => Looks up "Charlie", not found
                                 // => Returns default value 0 instead of null
                                 // => defaultAge is 0 (Charlie not in map)

// CHECK existence
boolean hasAlice = ages.containsKey("Alice");
                                 // => hasAlice is true
boolean has25 = ages.containsValue(25);
                                 // => has25 is true

// REMOVE
ages.remove("Bob");              // => ages is {"Alice": 31}

// ITERATE over entries
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
    // => Output: Alice: 31
}

import java.util.HashSet;

// CREATE HashSet
HashSet<String> unique = new HashSet<>();

// ADD elements (duplicates ignored)
unique.add("apple");             // => unique is {"apple"}, returns true (added)
unique.add("banana");            // => unique is {"apple", "banana"}
unique.add("apple");             // => unique unchanged (duplicate), returns false (not added)

// CONTAINS check
boolean has = unique.contains("apple");
                                 // => has is true (O(1) lookup via hash)

// REMOVE
unique.remove("banana");         // => unique is {"apple"}

// SIZE
int count = unique.size();       // => count is 1

// ITERATE (unordered!)
for (String item : unique) {
    System.out.println(item);    // => Output: apple (order not guaranteed)
}

// SET OPERATIONS
HashSet<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
HashSet<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5));

set1.addAll(set2);               // => Union: set1 is {1, 2, 3, 4, 5}
// set1.retainAll(set2);         // => Intersection: keeps only elements in both
// set1.removeAll(set2);         // => Difference: removes elements in set2

// TERNARY OPERATOR - inline conditional expression
int age = 20;                    // => age is 20 (primitive int)
String status = (age >= 18) ? "adult" : "minor";
                                 // => Ternary syntax: (condition) ? valueIfTrue : valueIfFalse
                                 // => Evaluates age >= 18 → true
                                 // => Returns "adult" (true branch)
                                 // => status is "adult" (20 >= 18 is true)

// Equivalent if/else (more verbose)
String status2;
if (age >= 18) {
    status2 = "adult";
} else {
    status2 = "minor";
}

// SHORT-CIRCUIT OPERATORS
boolean a = true;
boolean b = false;

boolean and = a && b;            // => and is false (both must be true)
                                 // => Short-circuit: if a is false, b never evaluated
boolean or = a || b;             // => or is true (at least one true)
                                 // => Short-circuit: if a is true, b never evaluated

// Short-circuit prevents null pointer errors
String str = null;
if (str != null && str.length() > 0) {
                                 // => str.length() only called if str != null
                                 // => Safe: no NullPointerException
    System.out.println("Non-empty string");
}

// COMPARISON OPERATORS
int x = 10;
int y = 20;
boolean equal = (x == y);        // => false (value equality)
boolean notEqual = (x != y);     // => true
boolean greater = (x > y);       // => false
boolean lessOrEqual = (x <= y);  // => true

// REFERENCE vs VALUE equality
String s1 = new String("hello");
String s2 = new String("hello");
boolean refEqual = (s1 == s2);   // => false (different objects, different memory addresses)
boolean valueEqual = s1.equals(s2);
                                 // => true (same content via equals() method)

import java.util.*;

// ENHANCED FOR with ArrayList
ArrayList<String> fruits = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));

for (String fruit : fruits) {    // => "for each fruit in fruits"
    System.out.println(fruit);   // => Output: apple, banana, cherry (order preserved)
}

// TRADITIONAL for loop (when index needed)
for (int i = 0; i < fruits.size(); i++) {
    System.out.println(i + ": " + fruits.get(i));
    // => Output: 0: apple, 1: banana, 2: cherry
}

// ITERATOR - manual iteration with remove support
Iterator<String> iter = fruits.iterator();
                                 // => Create iterator from collection
while (iter.hasNext()) {         // => Check if more elements remain
    String fruit = iter.next();  // => Get next element and advance
    System.out.println(fruit);
    if (fruit.equals("banana")) {
        iter.remove();           // => Safe removal during iteration
    }                            // => fruits is now ["apple", "cherry"]
}

// CAUTION: ConcurrentModificationException
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
for (Integer num : numbers) {
    // numbers.remove(num);      // => ERROR: ConcurrentModificationException
    // => Cannot modify collection during enhanced for-loop
}

// CORRECT removal: use Iterator.remove() or removeIf()
numbers.removeIf(num -> num % 2 == 0);
                                 // => Removes even numbers, numbers is [1, 3]

// METHOD DEFINITION
public static int add(int a, int b) {
                                 // => public: accessible from anywhere
                                 // => static: belongs to class (no object needed)
                                 // => int: return type
                                 // => add: method name
                                 // => (int a, int b): parameter list
    return a + b;                // => return keyword sends value back to caller
}

// METHOD CALL
int sum = add(5, 3);             // => sum is 8 (result of 5 + 3)
                                 // => Arguments 5 and 3 are copied to parameters a and b

// PASS-BY-VALUE for primitives
public static void modifyPrimitive(int x) {
    x = 100;                     // => Modifies local copy of parameter x, NOT original variable
                                 // => Parameter x is separate variable with copied value
}

int num = 10;                    // => num is 10 (primitive int on stack)
modifyPrimitive(num);            // => Copies value 10 to parameter x
                                 // => num still 10 after method returns (primitive pass-by-value)

// PASS-BY-VALUE for references (reference itself is copied)
public static void modifyArray(int[] arr) {
    arr[0] = 999;                // => Modifies heap object (reference points to same array)
}

public static void reassignArray(int[] arr) {
    arr = new int[]{100, 200};   // => Reassigns local reference copy (original unchanged)
}

int[] numbers = {1, 2, 3};
modifyArray(numbers);            // => numbers is [999, 2, 3] (heap object modified)
reassignArray(numbers);          // => numbers still [999, 2, 3] (reference copy reassigned)

// RETURN VALUES
public static String greet(String name) {
    return "Hello, " + name;     // => Return String object reference
}

String message = greet("Alice"); // => message is "Hello, Alice"

// VOID METHODS (no return value)
public static void printMessage(String msg) {
    System.out.println(msg);     // => Side effect (output) instead of return value
}                                // => Implicit return at end (no return statement needed)

// TRY-CATCH - handle exceptions
try {                            // => Protected code block (exceptions caught)
    int result = 10 / 0;         // => ArithmeticException: division by zero
    System.out.println(result);  // => Never executed (exception thrown above)
} catch (ArithmeticException e) {// => Catch specific exception type
    System.out.println("Cannot divide by zero!");
    // => Output: Cannot divide by zero!
}

// MULTIPLE CATCH blocks
try {
    String text = null;
    System.out.println(text.length());
                                 // => NullPointerException (text is null)
} catch (NullPointerException e) {
    System.out.println("Null reference!");
    // => Output: Null reference!
} catch (Exception e) {          // => Catch-all for remaining exceptions
    System.out.println("Other error: " + e.getMessage());
}

// FINALLY block (always executes)
Scanner scanner = null;
try {
    scanner = new Scanner(System.in);
    // ... use scanner ...
} catch (Exception e) {
    System.out.println("Error: " + e);
} finally {                      // => Executes whether exception thrown or not
    if (scanner != null) {
        scanner.close();         // => Cleanup resources (always runs)
    }
}

// TRY-WITH-RESOURCES (Java 7+, automatic resource management)
try (Scanner s = new Scanner(System.in)) {
                                 // => Resources declared in () auto-close after try
    String input = s.nextLine();
}                                // => Scanner.close() called automatically (even if exception)

// THROWING EXCEPTIONS
public static void checkAge(int age) throws IllegalArgumentException {
                                 // => throws declares method can throw exception
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative");
                                 // => throw keyword creates and throws exception
    }
}

try {
    checkAge(-5);                // => Throws IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println(e.getMessage());
    // => Output: Age cannot be negative
}

String text = "Hello, World!";

// LENGTH and CHARACTER ACCESS
int len = text.length();         // => len is 13 (method, not property)
char first = text.charAt(0);     // => first is 'H' (0-indexed)

// SUBSTRING
String hello = text.substring(0, 5);
                                 // => hello is "Hello" (end index exclusive: [0, 5))
String world = text.substring(7);// => world is "World!" (from index 7 to end)

// CONCATENATION
String greeting = "Hi" + " " + "there";
                                 // => greeting is "Hi there" (+ operator)
String concat = "Hello".concat(" World");
                                 // => concat is "Hello World" (.concat() method)

// CASE CONVERSION
String upper = text.toUpperCase();
                                 // => upper is "HELLO, WORLD!" (original unchanged)
String lower = text.toLowerCase();
                                 // => lower is "hello, world!"

// TRIMMING
String padded = "  text  ";
String trimmed = padded.trim();  // => trimmed is "text" (removes leading/trailing whitespace)

// SEARCH
boolean contains = text.contains("World");
                                 // => contains is true (substring search)
boolean starts = text.startsWith("Hello");
                                 // => starts is true
int index = text.indexOf("World");
                                 // => index is 7 (first occurrence, -1 if not found)

// REPLACEMENT
String replaced = text.replace("World", "Java");
                                 // => replaced is "Hello, Java!" (original unchanged)

// SPLITTING
String csv = "apple,banana,cherry";
String[] fruits = csv.split(",");// => fruits is ["apple", "banana", "cherry"]

// IMMUTABILITY demonstration
String original = "Java";
original.toUpperCase();          // => Returns "JAVA" but original unchanged
System.out.println(original);    // => Output: Java (still lowercase!)

String modified = original.toUpperCase();
                                 // => Must assign to new variable to capture result
System.out.println(modified);    // => Output: JAVA

// STRING CONCATENATION (inefficient in loops)
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + " ";           // => Creates 1000 temporary String objects (slow!)
}

// STRINGBUILDER (efficient)
StringBuilder sb = new StringBuilder();
                                 // => Mutable character buffer (default capacity 16 chars)
                                 // => Internal char[] array grows when capacity exceeded
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(" ");    // => append() modifies internal buffer in-place
                                 // => First append adds number, second adds space
                                 // => Method chaining: append() returns this for fluent API
                                 // => No temporary String objects created (O(n) vs O(n²))
}                                // => Loop completes with all 1000 numbers in buffer
String efficient = sb.toString();// => Convert final buffer to immutable String
                                 // => Creates single String from accumulated characters
                                 // => efficient is "0 1 2 ... 999 " (1000 numbers + spaces)

// COMMON StringBuilder OPERATIONS
StringBuilder builder = new StringBuilder("Hello");
builder.append(" World");        // => builder contains "Hello World"
builder.insert(5, ",");          // => builder contains "Hello, World"
builder.replace(7, 12, "Java");  // => builder contains "Hello, Java"
builder.delete(5, 6);            // => builder contains "Hello Java"
builder.reverse();               // => builder contains "avaJ olleH"

String final = builder.toString();
                                 // => final is "avaJ olleH"

// INITIAL CAPACITY (performance optimization)
StringBuilder sized = new StringBuilder(1000);
                                 // => Pre-allocate capacity to avoid resizing
// => Default capacity (16) doubles when full (expensive array copy)
// => Pre-sizing avoids resizing overhead for known large strings

import java.util.*;

// GENERIC COLLECTIONS
ArrayList<String> strings = new ArrayList<>();
                                 // => <String> specifies element type
strings.add("hello");            // => Type-safe: only String allowed
strings.add("world");
// strings.add(42);              // => Compile error: incompatible types

String first = strings.get(0);   // => No cast needed (compiler knows type is String)

// PRE-GENERICS (Java 1.4 and earlier)
ArrayList rawList = new ArrayList();
                                 // => Raw type (no generic parameter)
rawList.add("text");
rawList.add(123);                // => Accepts any type (no compile-time safety)
String str = (String) rawList.get(0);
                                 // => Requires explicit cast (runtime ClassCastException risk)

// GENERIC METHODS
public static <T> void printArray(T[] array) {
                                 // => <T> declares type parameter
                                 // => T can be any type (String, Integer, etc.)
    for (T element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

Integer[] numbers = {1, 2, 3};
String[] words = {"hello", "world"};
printArray(numbers);             // => T inferred as Integer, Output: 1 2 3
printArray(words);               // => T inferred as String, Output: hello world

// BOUNDED TYPE PARAMETERS
public static <T extends Number> double sum(List<T> list) {
                                 // => T must be Number or subclass (Integer, Double, etc.)
    double total = 0;
    for (T num : list) {
        total += num.doubleValue();
                                 // => Can call Number methods (T extends Number)
    }
    return total;
}

List<Integer> ints = Arrays.asList(1, 2, 3);
double result = sum(ints);       // => result is 6.0

// WILDCARD TYPES
public static void printList(List<?> list) {
                                 // => ? is wildcard (unknown type)
                                 // => Can accept List<String>, List<Integer>, etc.
    for (Object elem : list) {   // => Elements treated as Object (unknown type)
        System.out.print(elem + " ");
    }
}

List<String> names = Arrays.asList("Alice", "Bob");
List<Integer> nums = Arrays.asList(1, 2, 3);
printList(names);                // => Output: Alice Bob
printList(nums);                 // => Output: 1 2 3

// VARARGS METHOD
public static int sum(int... numbers) {
                                 // => int... allows 0 or more int arguments
                                 // => numbers is treated as int[] inside method
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

// CALLING with different argument counts
int result1 = sum();             // => result1 is 0 (no arguments, empty array)
int result2 = sum(5);            // => result2 is 5 (one argument)
int result3 = sum(1, 2, 3, 4);   // => result3 is 10 (four arguments)

// VARARGS with regular parameters
public static String format(String template, Object... args) {
                                 // => Regular parameter first, varargs last
    return String.format(template, args);
                                 // => args passed to format() as array
}

String msg = format("Hello %s, you have %d messages", "Alice", 5);
                                 // => msg is "Hello Alice, you have 5 messages"

// VARARGS vs ARRAY parameter
public static void printArray(int[] array) {
                                 // => Requires explicit array
    for (int n : array) {
        System.out.print(n + " ");
    }
}

printArray(new int[]{1, 2, 3});  // => Must create array explicitly

// Varargs equivalent (cleaner call syntax)
public static void printVarargs(int... numbers) {
    for (int n : numbers) {
        System.out.print(n + " ");
    }
}

printVarargs(1, 2, 3);           // => No explicit array creation needed

// VARARGS RULES
// 1. Only one varargs parameter allowed per method
// 2. Varargs must be LAST parameter
// public static void invalid(int... a, String s) {}  // => ERROR: varargs not last