Core Java Interview Questions and Answers: 60 Questions from Easy to Hard

final class Employee {
    private final String empId;
    private String name;               // not part of identity

    Employee(String empId, String name) {
        this.empId = Objects.requireNonNull(empId);
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee other)) return false;
        return empId.equals(other.empId);
    }

    @Override
    public int hashCode() {
        return empId.hashCode();
    }
}

record Emp(String name, String city, int years) { }

List<Emp> team = new ArrayList<>(List.of(
    new Emp("Ravi", "Pune", 3),
    new Emp("Asha", "Delhi", 7),
    new Emp("Neha", "Pune", 7)));

team.sort(Comparator.comparing(Emp::city)
    .thenComparing(Comparator.comparingInt(Emp::years).reversed())
    .thenComparing(Emp::name));
// Asha (Delhi, 7), Neha (Pune, 7), Ravi (Pune, 3)

List<String> leaves = new ArrayList<>(
        List.of("approved", "pending", "rejected", "pending"));

// Broken: throws ConcurrentModificationException
for (String s : leaves) {
    if (s.equals("pending")) {
        leaves.remove(s);
    }
}

// Fix 1: remove through the iterator
Iterator<String> it = leaves.iterator();
while (it.hasNext()) {
    if (it.next().equals("pending")) {
        it.remove();
    }
}

// Fix 2 (Java 8+): one line
leaves.removeIf(s -> s.equals("pending"));

static double total(List<? extends Number> amounts) {
    double sum = 0;
    for (Number n : amounts) {      // reading is safe
        sum += n.doubleValue();
    }
    // amounts.add(5);              // compile error
    return sum;
}

static void addDefaults(List<? super Integer> target) {
    target.add(0);                  // adding Integers is safe
    target.add(100);
}

total(List.of(10, 20));             // a List<Integer>
total(List.of(2.5, 4.0));           // a List<Double>
addDefaults(new ArrayList<Number>());

class Repo<T> {
    private final Supplier<T> factory;

    Repo(Supplier<T> factory) {
        this.factory = factory;
    }

    T create() {
        // return new T();    // compile error: T is erased
        return factory.get();
    }
}

Repo<StringBuilder> r = new Repo<>(StringBuilder::new);

// Does not compile: both erase to process(List)
// void process(List<String> a) { }
// void process(List<Integer> b) { }

// With Object obj:
// obj instanceof List<String>   compile error
// obj instanceof List<?>        fine

public class PayrollException extends RuntimeException {
    public PayrollException(String message) {
        super(message);
    }
    public PayrollException(String message, Throwable cause) {
        super(message, cause);
    }
}

try {
    payslipDao.save(slip);
} catch (SQLException e) {
    // keep e as the cause, or the root error is lost
    throw new PayrollException("Save failed: " + slip.id(), e);
}

class Res implements AutoCloseable {
    private final String name;
    Res(String name) { this.name = name; }
    @Override
    public void close() {
        System.out.println("close " + name);
    }
}

try (Res db = new Res("db"); Res file = new Res("file")) {
    System.out.println("work");
} finally {
    System.out.println("finally");
}
// work
// close file
// close db
// finally

record Emp(String id, String city) { }

List<Emp> staff = List.of(
    new Emp("E1", "Pune"),
    new Emp("E2", "Pune"),
    new Emp("E3", "Jaipur"));

// IllegalStateException: Duplicate key Pune ...
Map<String, String> bad = staff.stream()
    .collect(Collectors.toMap(Emp::city, Emp::id));

// Combine ids per city, in a sorted map
Map<String, String> ok = staff.stream()
    .collect(Collectors.toMap(Emp::city, Emp::id,
        (a, b) -> a + "," + b, TreeMap::new));
// {Jaipur=E3, Pune=E1,E2}

Optional<Integer> first = Stream.of(1, 2, 3, 4)
    .filter(n -> {
        System.out.println("filter " + n);
        return n % 2 == 0;
    })
    .map(n -> {
        System.out.println("map " + n);
        return n * 10;
    })
    .findFirst();

System.out.println(first.get());
// filter 1
// filter 2
// map 2
// 20

class Counter {
    private int unsafe = 0;
    private final AtomicInteger safe = new AtomicInteger();

    void hit() {
        unsafe++;                // read, add, write: can lose updates
        safe.incrementAndGet();  // atomic
    }
}

Counter c = new Counter();
Runnable work = () -> {
    for (int i = 0; i < 10_000; i++) c.hit();
};
Thread t1 = new Thread(work), t2 = new Thread(work);
t1.start(); t2.start();
t1.join(); t2.join();
// safe is always 20000; unsafe can be less

String path = "a.b.c";
System.out.println(path.split(".").length);      // 0
System.out.println(path.split("\\.").length);    // 3

String row = "Ravi,Pune,,";
System.out.println(row.split(",").length);       // 2
System.out.println(row.split(",", -1).length);   // 4

String ver = "21|LTS";
String[] parts = ver.split(Pattern.quote("|"));  // [21, LTS]

System.out.println(0.1 + 0.2);    // 0.30000000000000004

BigDecimal a = new BigDecimal("0.1");
System.out.println(a.add(new BigDecimal("0.2")));    // 0.3
System.out.println(new BigDecimal(0.1));
// 0.1000000000000000055511151231257827021181583404541015625

BigDecimal fee = new BigDecimal("1000");
BigDecimal share =
    fee.divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP);
System.out.println(share);                          // 333.33

BigDecimal x = new BigDecimal("2.0");
BigDecimal y = new BigDecimal("2.00");
System.out.println(x.equals(y));                    // false
System.out.println(x.compareTo(y));                 // 0

record Team(String name, List<String> members) {
    Team {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("name required");
        }
        name = name.strip();
        members = List.copyOf(members);   // defensive copy
    }
}

List<String> list = new ArrayList<>(List.of("Anil"));
Team t = new Team(" QA ", list);
list.add("Zoya");                         // does not affect t
System.out.println(t.members());          // [Anil]
System.out.println(t.name());             // QA
// t.members().add("X") throws UnsupportedOperationException

record Circle(double r) { }
record Rect(double w, double h) { }

// Java 16+: type pattern, no cast
if (obj instanceof String s && !s.isBlank()) {
    System.out.println(s.length());
}

// Java 21: record patterns and guards in switch
static String describe(Object o) {
    return switch (o) {
        case null -> "nothing";
        case Circle(double r) when r == 0 -> "a point";
        case Circle(double r) -> "circle, radius " + r;
        case Rect(double w, double h) -> "area " + (w * h);
        default -> "unknown";
    };
}

interface Camera {
    default String start() { return "camera on"; }
}
interface Gps {
    default String start() { return "gps on"; }
}

class Phone implements Camera, Gps {
    @Override
    public String start() {          // required, or compile error
        return Camera.super.start() + ", " + Gps.super.start();
    }
}

System.out.println(new Phone().start());   // camera on, gps on