Java interview questions

javac Hello.java        # compile: produces Hello.class
java Hello              # run: the JVM loads and executes the bytecode
java Hello.java         # Java 11+: compile in memory and run a single-file program

public class Greeter {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "world";
        System.out.println("Hello, " + name);
    }
}

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

public class Boxing {
    public static void main(String[] args) {
        List<Integer> marks = new ArrayList<>();
        marks.add(85);                      // autoboxing: int 85 -> Integer.valueOf(85)
        int first = marks.get(0);           // unboxing: Integer -> int
        System.out.println(first + 5);      // 90

        Integer missing = null;
        int value = missing;                // unboxing null: NullPointerException
    }
}

public class PassByValue {
    static void change(StringBuilder sb) {
        sb.append("!");                    // changes the shared object
        sb = new StringBuilder("Bye");     // re-points the local copy only
        sb.append("?");                    // affects the new object, which nobody else sees
    }

    public static void main(String[] args) {
        StringBuilder greeting = new StringBuilder("Hi");
        change(greeting);
        System.out.println(greeting);      // Hi!
    }
}

public class IntegerCache {
    public static void main(String[] args) {
        Integer a = 127, b = 127;
        Integer c = 128, d = 128;
        System.out.println(a == b);          // true: the same cached object
        System.out.println(c == d);          // false: two different objects
        System.out.println(c.equals(d));     // true: compares the values
        System.out.println(c.intValue() == d.intValue());   // true: compares ints
    }
}

public class StringPool {
    public static void main(String[] args) {
        String a = "java";                 // the literal lives in the String pool
        String b = "java";                 // reuses the same pooled object
        String c = new String("java");     // a new object on the heap, outside the pool
        String d = c.intern();             // fetches the pooled copy

        System.out.println(a == b);        // true
        System.out.println(a == c);        // false
        System.out.println(a == d);        // true

        String upper = a.toUpperCase();    // a new String; a is unchanged
        System.out.println(a + " " + upper);   // java JAVA
    }
}

public class Builders {
    public static void main(String[] args) {
        String csv = "";
        for (int i = 1; i <= 5; i++) {
            csv += i + ",";                  // a new String every iteration
        }
        System.out.println(csv);             // 1,2,3,4,5,

        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(',');        // one buffer, grown as needed
        }
        sb.setLength(sb.length() - 1);       // drop the trailing comma
        System.out.println(sb);              // 1,2,3,4,5
        System.out.println(sb.reverse());    // 5,4,3,2,1: mutating methods change sb itself
    }
}

public class StringEquality {
    public static void main(String[] args) {
        String a = "java", b = "java";
        String c = new String("java");

        System.out.println(a == b);              // true: one pooled object
        System.out.println(a == c);              // false: c is a separate object
        System.out.println(a.equals(c));         // true: same characters

        String d = "ja" + "va";                  // compile-time constant: folded into "java"
        String part = "ja";
        String e = part + "va";                  // built at runtime: a new object
        System.out.println(a == d);              // true
        System.out.println(a == e);              // false
        System.out.println(a == e.intern());     // true
    }
}

import java.util.List;

abstract class Payment {                                  // abstraction: what a payment does
    private final double amount;                          // encapsulation: hidden state

    Payment(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
        this.amount = amount;                             // validated before it's stored
    }

    double getAmount() { return amount; }                 // controlled read access

    abstract String pay();                                // how: left to subclasses
}

class UpiPayment extends Payment {                        // inheritance
    private final String upiId;
    UpiPayment(double amount, String upiId) { super(amount); this.upiId = upiId; }
    @Override String pay() { return "Paid ₹" + getAmount() + " via UPI to " + upiId; }
}

class CardPayment extends Payment {
    CardPayment(double amount) { super(amount); }
    @Override String pay() { return "Paid ₹" + getAmount() + " by card"; }
}

public class Pillars {
    public static void main(String[] args) {
        List<Payment> payments = List.of(new UpiPayment(499, "asha@okbank"), new CardPayment(1299));
        for (Payment p : payments) {
            System.out.println(p.pay());                  // polymorphism: each type's own pay()
        }
    }
}

class Notifier {
    void send(String to) { System.out.println("email to " + to); }
    void send(String to, String subject) { System.out.println("email to " + to + ": " + subject); }   // overload
    void send(long phone) { System.out.println("SMS to " + phone); }                                 // overload
}

class SlackNotifier extends Notifier {
    @Override
    void send(String to) { System.out.println("Slack message to " + to); }    // override
}

public class Polymorphism {
    public static void main(String[] args) {
        Notifier n = new SlackNotifier();      // declared as Notifier, really a SlackNotifier
        n.send("asha");                        // Slack message to asha: chosen at runtime
        n.send("asha", "Offer letter");        // email to asha: Offer letter: inherited overload
        n.send(9876543210L);                   // SMS to 9876543210: chosen at compile time
    }
}

interface Walker {
    default String move() { return "walk"; }
}

interface Swimmer {
    default String move() { return "swim"; }
}

class Duck implements Walker, Swimmer {
    @Override
    public String move() {                                   // required: the compiler won't choose
        return Walker.super.move() + " and " + Swimmer.super.move();
    }
}

public class Diamond {
    public static void main(String[] args) {
        System.out.println(new Duck().move());               // walk and swim
    }
}

public class Overloads {
    static void print(long x) { System.out.println("long"); }
    static void print(Integer x) { System.out.println("Integer"); }
    static void print(int... x) { System.out.println("varargs"); }

    public static void main(String[] args) {
        print(5);             // long
        print(5L);            // long: an exact match
        print(Integer.valueOf(5));   // Integer: an exact match
        print();              // varargs: nothing else takes zero arguments
        print(1, 2);          // varargs
    }
}

class Account {
    protected final String owner;
    protected double balance;

    Account(String owner) {
        this(owner, 0.0);                            // this(): reuse the other constructor
    }

    Account(String owner, double opening) {
        // super() is inserted here automatically: Object's constructor
        this.owner = owner;                          // this.field vs the parameter of the same name
        this.balance = opening;
        System.out.println("Account for " + owner);
    }
}

class SavingsAccount extends Account {
    private final double rate;

    SavingsAccount(String owner, double rate) {
        super(owner, 1000.0);                         // super(): the parent part is built first
        this.rate = rate;
        System.out.println("Savings at " + rate + "%");
    }
}

public class Constructors {
    public static void main(String[] args) {
        new SavingsAccount("Asha", 7.0);
    }
}

class Employee {
    static int count = 0;                      // one copy, shared by all employees
    static final String COMPANY;               // a constant
    final String name;

    static {                                   // runs once, when the class loads
        COMPANY = "CareersAt Corp";
    }

    Employee(String name) {
        this.name = name;
        count++;
    }

    static String describe() { return "Employee"; }
}

class Manager extends Employee {
    Manager(String name) { super(name); }
    static String describe() { return "Manager"; }   // hides Employee.describe()
}

public class StaticDemo {
    public static void main(String[] args) {
        new Employee("Asha");
        new Manager("Ravi");
        System.out.println(Employee.count);           // 2: shared counter
        System.out.println(Employee.COMPANY);         // CareersAt Corp

        Employee e = new Manager("Priya");
        System.out.println(e.describe());             // Employee: chosen by the declared type
        System.out.println(Manager.describe());       // Manager
    }
}

final class TaxRates {                              // final class: no subclasses
    static final double GST = 0.18;                 // final variable: a constant
}

class Report {
    final String title;                             // must be assigned once, in the constructor
    Report(String title) { this.title = title; }

    final String header() { return "== " + title + " =="; }   // final method: can't be overridden
}

public class FinalDemo {
    public static void main(String[] args) {
        final int limit = 3;
        // limit = 4;                               // compile error: cannot assign a value to final variable limit

        try {
            System.out.println(new Report("Sales").header());
        } finally {
            System.out.println("finally always runs");   // cleanup goes here
        }
    }
}

// file: com/shop/billing/Invoice.java
package com.shop.billing;

public class Invoice {
    private double discount;           // only Invoice itself
    double subtotal;                   // default: anything in com.shop.billing
    protected double tax;              // com.shop.billing, plus subclasses anywhere
    public double total() { return subtotal + tax - discount; }
}

// file: com/shop/reports/GstInvoice.java
package com.shop.reports;

import com.shop.billing.Invoice;

public class GstInvoice extends Invoice {
    void applyGst() {
        tax = 18.0;                    // OK: protected, inherited by this subclass
        // subtotal = 100;             // compile error: default access, different package
        // discount = 5;               // compile error: private
    }
}

interface Discountable {                          // a capability: anything that can be discounted
    double discountPercent();                     // abstract by default

    default double priceAfterDiscount(double price) {      // Java 8: default method
        return round(price * (1 - discountPercent() / 100));
    }

    static double gst(double price) { return price * 0.18; }   // Java 8: static method

    private static double round(double v) { return Math.round(v * 100) / 100.0; }   // Java 9: private
}

abstract class Product {                          // a family with shared state
    protected final String name;
    protected final double price;

    protected Product(String name, double price) {          // abstract classes have constructors
        this.name = name;
        this.price = price;
    }

    abstract String category();                    // each kind of product must say what it is

    String label() { return name + " (" + category() + "): ₹" + price; }   // shared code
}

class Book extends Product implements Discountable {
    Book(String name, double price) { super(name, price); }
    @Override String category() { return "Books"; }
    @Override public double discountPercent() { return 10; }
}

public class AbstractVsInterface {
    public static void main(String[] args) {
        Book book = new Book("Clean Code", 650);
        System.out.println(book.label());                       // Clean Code (Books): ₹650.0
        System.out.println(book.priceAfterDiscount(book.price)); // 585.0
        System.out.println(Discountable.gst(1000));              // 180.0
    }
}

@FunctionalInterface
interface PriceRule {
    double apply(double price);                       // the single abstract method

    default PriceRule then(PriceRule next) {          // defaults are allowed
        return price -> next.apply(apply(price));
    }
}

public class FunctionalDemo {
    static double addGst(double price) {
        return price * 1.18;
    }

    public static void main(String[] args) {
        PriceRule festiveSale = price -> price * 0.9;        // a lambda
        PriceRule gst = FunctionalDemo::addGst;              // a method reference

        System.out.println(festiveSale.apply(1000));         // 900.0
        System.out.println(gst.apply(1000));                 // 1180.0
        System.out.println(festiveSale.then(gst).apply(1000));   // 1062.0: sale, then GST
    }
}

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

final class Employee {
    private final int id;
    private final String name;

    Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                       // same object
        if (!(o instanceof Employee other)) return false; // null or a different type (Java 16 pattern)
        return id == other.id;                            // identity is the employee id
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);                          // the same field as equals()
    }

    @Override
    public String toString() { return "Employee(" + id + ", " + name + ")"; }
}

public class EqualsHashCode {
    public static void main(String[] args) {
        Map<Employee, String> desks = new HashMap<>();
        desks.put(new Employee(42, "Asha"), "Desk 7B");

        Employee lookup = new Employee(42, "Asha");           // a different object, equal by id
        System.out.println(desks.get(lookup));                // Desk 7B
        System.out.println(lookup.equals(new Employee(42, "A. Rao")));   // true: same id
    }
}

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

public final class Candidate {                           // final: no mutable subclasses
    private final String name;
    private final List<String> skills;

    public Candidate(String name, List<String> skills) {
        this.name = name;
        this.skills = List.copyOf(skills);               // defensive copy, and unmodifiable
    }

    public String getName() { return name; }
    public List<String> getSkills() { return skills; }   // safe to return: nobody can change it

    public Candidate withSkill(String skill) {           // "changes" return a new object
        List<String> more = new ArrayList<>(skills);
        more.add(skill);
        return new Candidate(name, more);
    }

    public static void main(String[] args) {
        List<String> input = new ArrayList<>(List.of("Java", "SQL"));
        Candidate asha = new Candidate("Asha", input);

        input.add("Hacking");                            // the caller changes its own list...
        System.out.println(asha.getSkills());            // [Java, SQL]: ...without affecting asha

        Candidate updated = asha.withSkill("Spring");
        System.out.println(updated.getSkills());         // [Java, SQL, Spring]
        System.out.println(asha.getSkills());            // [Java, SQL]: the original is unchanged

        asha.getSkills().add("Docker");                  // UnsupportedOperationException
    }
}

final class Address {
    String city;                                   // mutable
    Address(String city) { this.city = city; }
}

// List.copyOf(addresses) creates a new list, but its elements are the SAME Address objects:
// address.city = "Delhi" through the caller's reference changes what the "immutable" object holds.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class CheckedDemo {
    static String readConfig(Path path) throws IOException {      // throws: declares it
        return Files.readString(path);                             // may throw IOException (checked)
    }

    static int parseAge(String text) {
        int age = Integer.parseInt(text);                          // may throw NumberFormatException (unchecked)
        if (age < 0) throw new IllegalArgumentException("age < 0"); // throw: raises it
        return age;
    }

    public static void main(String[] args) {
        try {
            readConfig(Path.of("missing.properties"));
        } catch (IOException e) {                                   // the compiler insists on this
            System.out.println("config not found: " + e.getClass().getSimpleName());
        }
        System.out.println(parseAge("21"));                         // 21: no try needed to compile
    }
}

public class FinallyReturn {
    static int value() {
        try {
            return 1;
        } finally {
            return 2;                    // replaces the 1; IDEs and javac -Xlint:finally warn about this
        }
    }

    static int swallow() {
        try {
            throw new IllegalStateException("lost");
        } finally {
            return -1;                   // the exception disappears
        }
    }

    static int noReturnInFinally() {
        int x = 1;
        try {
            return x;                    // the value 1 is saved here
        } finally {
            x = 99;                      // too late to change the saved return value
        }
    }

    public static void main(String[] args) {
        System.out.println(value());             // 2
        System.out.println(swallow());           // -1: no exception reaches main
        System.out.println(noReturnInFinally()); // 1
    }
}

class InsufficientBalanceException extends Exception {          // checked
    private final double shortfall;

    InsufficientBalanceException(double balance, double requested) {
        super(String.format("Balance ₹%.2f is less than ₹%.2f", balance, requested));
        this.shortfall = requested - balance;
    }

    double getShortfall() { return shortfall; }
}

class BankAccount {
    private double balance;

    BankAccount(double opening) { this.balance = opening; }

    void withdraw(double amount) throws InsufficientBalanceException {
        if (amount <= 0) {
            throw new IllegalArgumentException("amount must be positive");   // unchecked: a bug in the caller
        }
        if (amount > balance) {
            throw new InsufficientBalanceException(balance, amount);         // checked: an expected situation
        }
        balance -= amount;
    }

    double getBalance() { return balance; }
}

public class CustomException {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(5000);
        try {
            account.withdraw(2000);
            account.withdraw(4000);
        } catch (InsufficientBalanceException e) {
            System.out.println(e.getMessage());
            System.out.println("Short by ₹" + e.getShortfall());
        }
        System.out.println("Balance: ₹" + account.getBalance());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class ManualClose {
    static String firstLine(Path path) throws IOException {
        BufferedReader reader = null;
        try {
            reader = Files.newBufferedReader(path);
            return reader.readLine();
        } finally {
            if (reader != null) {
                reader.close();                       // can throw, hiding the original exception
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class AutoClose {
    static String firstLine(Path path) throws IOException {
        try (BufferedReader reader = Files.newBufferedReader(path)) {
            return reader.readLine();                 // reader.close() runs automatically
        }
    }
}

public class Suppressed {
    static class Resource implements AutoCloseable {
        private final String name;

        Resource(String name) {
            this.name = name;
            System.out.println("open " + name);
        }

        @Override
        public void close() throws Exception {
            System.out.println("close " + name);
            if (name.equals("B")) throw new Exception("close failed: B");
        }
    }

    public static void main(String[] args) {
        try (Resource a = new Resource("A"); Resource b = new Resource("B")) {
            throw new IllegalStateException("work failed");
        } catch (Exception e) {
            System.out.println("caught: " + e.getMessage());
            for (Throwable s : e.getSuppressed()) {
                System.out.println("suppressed: " + s.getMessage());
            }
        }
    }
}

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

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Asha", 24);
        ages.put("Ravi", 27);
        ages.put("Asha", 25);                       // same key: the value is replaced
        ages.put(null, 0);                          // one null key is allowed, in bucket 0

        System.out.println(ages.get("Asha"));       // 25
        System.out.println(ages.size());            // 3
        System.out.println(ages.containsKey(null)); // true

        System.out.println("Aa".hashCode() + " " + "BB".hashCode());   // 2112 2112: a real collision
    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Lists {
    public static void main(String[] args) {
        List<String> array = new ArrayList<>(List.of("a", "b", "c"));
        array.add(1, "x");                        // shifts "b" and "c" one place right
        System.out.println(array);                // [a, x, b, c]
        System.out.println(array.get(2));         // b: direct index

        LinkedList<String> linked = new LinkedList<>(List.of("a", "b", "c"));
        linked.addFirst("start");                 // O(1): relink the head
        linked.removeLast();                      // O(1): relink the tail
        System.out.println(linked);               // [start, a, b]
    }
}

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

record Employee(int id, String name, double salary) implements Comparable<Employee> {
    @Override
    public int compareTo(Employee other) {
        return Integer.compare(id, other.id);           // natural order: by id
    }
}

public class Sorting {
    public static void main(String[] args) {
        List<Employee> staff = new ArrayList<>(List.of(
                new Employee(3, "Priya", 120000),
                new Employee(1, "Asha", 250000),
                new Employee(4, "Arjun", 120000),
                new Employee(2, "Ravi", 180000)));

        staff.sort(null);                                // null = use the natural order (Comparable)
        System.out.println(staff.stream().map(Employee::name).toList());
        // [Asha, Ravi, Priya, Arjun]

        staff.sort(Comparator.comparingDouble(Employee::salary)
                .thenComparing(Employee::name));         // salary, then name for ties
        System.out.println(staff.stream().map(Employee::name).toList());
        // [Arjun, Priya, Ravi, Asha]

        staff.sort(Comparator.comparingDouble(Employee::salary).reversed());
        System.out.println(staff.get(0).name());         // Asha: highest salary first
    }
}

import java.util.*;

public class Hierarchy {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("Pune", "Delhi", "Pune"));
        Set<String> set = new TreeSet<>(list);                // unique and sorted
        Queue<Integer> queue = new PriorityQueue<>(List.of(5, 1, 3));
        Map<String, Integer> map = new LinkedHashMap<>();
        map.put("Pune", 2);
        map.put("Delhi", 1);

        System.out.println(list);              // [Pune, Delhi, Pune]
        System.out.println(set);               // [Delhi, Pune]
        System.out.println(queue.poll());      // 1: smallest first
        System.out.println(map.keySet());      // [Pune, Delhi]: a Set view of the keys
        System.out.println(map.entrySet());    // [Pune=2, Delhi=1]
    }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ConcurrentCounts {
    public static void main(String[] args) throws InterruptedException {
        Map<String, Integer> hits = new ConcurrentHashMap<>();
        ExecutorService pool = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 1000; i++) {
            pool.submit(() -> hits.merge("home", 1, Integer::sum));   // atomic read-modify-write
        }
        pool.shutdown();
        pool.awaitTermination(5, TimeUnit.SECONDS);
        System.out.println(hits.get("home"));                         // 1000, every time
    }
}

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class RemoveWhileIterating {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b", "c", "d"));
        try {
            for (String s : list) {
                if (s.equals("a")) list.remove(s);       // modifies the list behind the iterator's back
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("ConcurrentModificationException");
        }

        Iterator<String> it = list.iterator();           // list is now [b, c, d]
        while (it.hasNext()) {
            if (it.next().equals("b")) it.remove();      // safe: the iterator does the removal
        }
        list.removeIf(s -> s.equals("d"));               // safe and shortest
        System.out.println(list);                        // [c]

        List<String> cow = new CopyOnWriteArrayList<>(List.of("a", "b"));
        for (String s : cow) cow.add(s + "!");           // fail-safe: loops over a snapshot
        System.out.println(cow);                         // [a, b, a!, b!]
    }
}

import java.util.List;
import java.util.stream.Stream;

public class Streams {
    public static void main(String[] args) {
        List<String> names = List.of("Asha", "Ravi", "Priya", "Arjun");

        Stream<String> pipeline = names.stream()
                .filter(n -> {
                    System.out.println("filter " + n);
                    return n.startsWith("A");
                })
                .map(String::toUpperCase);
        System.out.println("nothing has run yet");
        System.out.println(pipeline.toList());               // the terminal operation starts it

        List<List<String>> teams = List.of(List.of("Asha", "Ravi"), List.of("Priya"));
        System.out.println(teams.stream().map(List::size).toList());              // [2, 1]
        System.out.println(teams.stream().flatMap(List::stream).toList());        // [Asha, Ravi, Priya]
    }
}

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.function.Function;
import java.util.stream.Collectors;

record Employee(String name, String dept, double salary) {}

public class GroupBy {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
                new Employee("Asha", "Engineering", 250000),
                new Employee("Ravi", "Engineering", 180000),
                new Employee("Priya", "Engineering", 120000),
                new Employee("Sneha", "Sales", 150000),
                new Employee("Sana", "Sales", 160000),
                new Employee("Meera", "HR", 85000));

        Map<String, Double> avg = staff.stream()
                .collect(Collectors.groupingBy(Employee::dept, TreeMap::new,
                        Collectors.averagingDouble(Employee::salary)));
        System.out.println(avg);
        // {Engineering=183333.33333333334, HR=85000.0, Sales=155000.0}

        Map<String, Optional<Employee>> top = staff.stream()
                .collect(Collectors.groupingBy(Employee::dept, TreeMap::new,
                        Collectors.maxBy(Comparator.comparingDouble(Employee::salary))));
        top.forEach((dept, e) -> System.out.println(dept + ": " + e.get().name()));
        // Engineering: Asha
        // HR: Meera
        // Sales: Sana

        Optional<Double> secondHighest = staff.stream()
                .map(Employee::salary).distinct()
                .sorted(Comparator.reverseOrder())
                .skip(1).findFirst();
        System.out.println(secondHighest.orElseThrow());     // 180000.0

        Map<Character, Long> letters = "banana".chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.groupingBy(Function.identity(), TreeMap::new, Collectors.counting()));
        System.out.println(letters);                          // {a=3, b=1, n=2}
    }
}

import java.util.Map;
import java.util.Optional;

public class OptionalDemo {
    static final Map<Integer, String> USERS = Map.of(1, "Asha", 2, "Ravi");

    static Optional<String> findName(int id) {
        return Optional.ofNullable(USERS.get(id));        // empty if there's no such user
    }

    static String expensiveDefault() {
        System.out.println("  (computing the default)");
        return "Guest";
    }

    public static void main(String[] args) {
        System.out.println(findName(1).orElse(expensiveDefault()));        // computes it, then prints Asha
        System.out.println(findName(1).orElseGet(() -> expensiveDefault())); // Asha: no computing
        System.out.println(findName(9).orElseGet(() -> expensiveDefault())); // computes it, prints Guest

        String upper = findName(2).map(String::toUpperCase).orElse("UNKNOWN");
        System.out.println(upper);                                          // RAVI
        findName(9).ifPresentOrElse(
                n -> System.out.println("found " + n),
                () -> System.out.println("no user 9"));                    // no user 9
    }
}

public class CreatingThreads {
    static class Worker extends Thread {                    // option 1: extend Thread
        @Override
        public void run() {
            System.out.println("Worker on " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () ->                               // option 2: a Runnable (preferred)
                System.out.println("task on " + Thread.currentThread().getName());

        Thread t1 = new Thread(task, "report-thread");
        t1.start();                                         // a new thread runs task
        t1.join();                                          // wait for it to finish

        Thread t2 = new Thread(task, "never-started");
        t2.run();                                           // no new thread: runs on main

        Worker w = new Worker();
        w.start();
        w.join();
    }
}

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public synchronized void incrementMethod() {     // locks "this" for the whole method
        count++;
    }

    public void incrementBlock() {
        // ...work that doesn't need the lock...
        synchronized (lock) {                        // locks only the critical section
            count++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter c = new Counter();
        Runnable work = () -> {
            for (int i = 0; i < 100_000; i++) c.incrementBlock();
        };
        Thread a = new Thread(work), b = new Thread(work);
        a.start(); b.start();
        a.join(); b.join();
        System.out.println(c.count);                 // 200000; without synchronized, usually less
    }
}

public class OrderDesk {
    private String order;

    public synchronized void place(String o) {
        order = o;
        notifyAll();                                 // wake threads waiting on this object
    }

    public synchronized String take() throws InterruptedException {
        while (order == null) {
            wait();                                  // releases the lock while waiting
        }
        String o = order;
        order = null;
        return o;
    }
}

public final class AppConfig {
    private static volatile AppConfig instance;      // volatile: no half-built objects leak out

    private final String env;

    private AppConfig() {                             // private: nobody else can construct one
        env = System.getProperty("env", "dev");
    }

    public static AppConfig getInstance() {
        AppConfig result = instance;                  // one volatile read on the common path
        if (result == null) {                         // first check, without locking
            synchronized (AppConfig.class) {
                result = instance;
                if (result == null) {                 // second check, inside the lock
                    instance = result = new AppConfig();
                }
            }
        }
        return result;
    }

    public String env() { return env; }

    public static void main(String[] args) {
        System.out.println(AppConfig.getInstance() == AppConfig.getInstance());   // true
        System.out.println(AppConfig.getInstance().env());                       // dev
    }
}

// EagerConfig.java
public final class EagerConfig {                       // created when the class loads
    private static final EagerConfig INSTANCE = new EagerConfig();
    private EagerConfig() {}
    public static EagerConfig getInstance() { return INSTANCE; }
}

// LazyConfig.java
public final class LazyConfig {                        // the holder idiom: lazy, no locks
    private LazyConfig() {}
    private static class Holder {
        static final LazyConfig INSTANCE = new LazyConfig();   // runs on first getInstance()
    }
    public static LazyConfig getInstance() { return Holder.INSTANCE; }
}

// EnumConfig.java
public enum EnumConfig {                               // the enum singleton
    INSTANCE;
    public String env() { return "dev"; }
}

import java.util.List;
import java.util.concurrent.*;

public class Executors101 {
    static int fetchPrice(String item) throws InterruptedException {
        Thread.sleep(200);                                // stands in for a slow API call
        return switch (item) {
            case "kettle" -> 1299;
            case "mixer" -> 2499;
            default -> 399;
        };
    }

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        try {
            List<Callable<Integer>> tasks = List.of(
                    () -> fetchPrice("kettle"),
                    () -> fetchPrice("mixer"),
                    () -> fetchPrice("bottle"));

            long start = System.currentTimeMillis();
            int total = 0;
            for (Future<Integer> f : pool.invokeAll(tasks)) {   // run all three at once
                total += f.get();                              // get() waits for each result
            }
            System.out.println("total ₹" + total);              // total ₹4197
            System.out.println("took about " + (System.currentTimeMillis() - start) / 100 * 100 + " ms");   // about 200, not 600

            Future<Integer> slow = pool.submit(() -> fetchPrice("kettle"));
            System.out.println(slow.get(1, TimeUnit.SECONDS));  // 1299, or TimeoutException after 1 s
        } finally {
            pool.shutdown();                                    // stop accepting work; let queued tasks finish
        }
    }
}

public class Deadlock {
    static final Object accountA = new Object();
    static final Object accountB = new Object();

    static void pause() {
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (accountA) {
                System.out.println("t1 locked A");
                pause();                                   // give t2 time to lock B
                synchronized (accountB) {                  // waits for t2: forever
                    System.out.println("t1 locked B");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (accountB) {
                System.out.println("t2 locked B");
                pause();
                synchronized (accountA) {                  // waits for t1: forever
                    System.out.println("t2 locked A");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

public class NoDeadlock {
    static final Object accountA = new Object();
    static final Object accountB = new Object();

    static void transfer(String who) {
        synchronized (accountA) {                          // everyone locks A first...
            synchronized (accountB) {                      // ...then B: no cycle is possible
                System.out.println(who + " moved money");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> transfer("t1"));
        Thread t2 = new Thread(() -> transfer("t2"));
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("done");                        // always reaches here
    }
}

public class Eligibility {
    static class Order {
        final int id;
        Order(int id) { this.id = id; }
    }

    public static void main(String[] args) {
        Order a = new Order(1);
        Order b = new Order(2);

        a = null;                     // Order 1: no references left, so eligible
        b = new Order(3);             // Order 2: its only reference was reassigned, so eligible

        Order c = new Order(4);
        Order d = c;
        c = null;                     // Order 4 is still reachable through d: not eligible

        System.gc();                  // a request; the JVM decides whether and when to collect
        System.out.println(d.id);     // 4
    }
}

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

public class MemoryErrors {
    static int depth = 0;

    static void recurse() {
        depth++;
        recurse();                               // no base case: a new frame for every call
    }

    public static void main(String[] args) {
        try {
            recurse();
        } catch (StackOverflowError e) {
            System.out.println("StackOverflowError after about " + depth / 1000 * 1000 + " calls");
        }

        List<long[]> hoard = new ArrayList<>();
        try {
            while (true) hoard.add(new long[1_000_000]);   // 8 MB each, all kept reachable
        } catch (OutOfMemoryError e) {
            int blocks = hoard.size();
            hoard.clear();                                  // release them so the program can continue
            System.out.println("OutOfMemoryError after " + blocks + " blocks of 8 MB");
        }
    }
}