Intermediate Java Interview Questions and Answers

If two objects are equals, they must return the same hashCode. (Different objects may share a hash code; that is a collision, which is allowed.) Hash-based collections first use hashCode to find a bucket, then equals to find the key, so overriding equals without hashCode breaks them:

import java.util.HashSet;
import java.util.Set;

class PointNoHash {
    final int x, y;
    PointNoHash(int x, int y) { this.x = x; this.y = y; }
    @Override public boolean equals(Object o) {
        return o instanceof PointNoHash p && p.x == x && p.y == y;
    }
}

record Point(int x, int y) {}   // generates both equals and hashCode

public class Main {
    public static void main(String[] args) {
        Set<PointNoHash> broken = new HashSet<>();
        broken.add(new PointNoHash(1, 2));
        System.out.println(broken.contains(new PointNoHash(1, 2)));

        Set<Point> fixed = new HashSet<>();
        fixed.add(new Point(1, 2));
        System.out.println(fixed.contains(new Point(1, 2)));
    }
}

false
true

• An abstract class can have state (fields), constructors and concrete methods; a class can extend only one. Use it for closely related classes that share code and state.
• An interface defines a capability; since Java 8 it can have default and static methods, but no instance state; a class can implement many. Use it for types and capabilities shared by unrelated classes, and to declare variables (List, not ArrayList).

Modern designs usually start with an interface, adding an abstract base class only to share implementation.

The ability to treat objects of different classes through a common supertype, with each object running its own overridden behaviour. Java chooses the implementation of an instance method at run time from the actual object (dynamic dispatch). Overloading, by contrast, is resolved at compile time.

Make the class final, all fields private final, set them in the constructor, provide no setters, return new objects from "modifying" methods, and make defensive copies of mutable inputs and outputs (for example List.copyOf). Records give you most of this automatically for simple data classes.

A record (Java 16+) is a compact, immutable data class: record Point(int x, int y) {} generates private final fields, a constructor, accessors (x()), and value-based equals, hashCode and toString. Use records for values defined by their data (DTOs, coordinates, results with several parts). They cannot extend classes or have mutable instance fields.

A HashMap keeps an array of buckets. For put(key, value) it computes key.hashCode(), spreads the bits, and picks a bucket index. Entries with the same bucket form a linked list, which since Java 8 turns into a balanced tree when a bucket grows large (so the worst case is O(log n) instead of O(n)). get finds the bucket the same way and compares keys with equals. When the number of entries exceeds capacity × load factor (0.75 by default), the table doubles and entries are redistributed (rehashing). Average get/put is O(1).

ArrayList is backed by a resizable array: O(1) access by index, amortized O(1) add at the end, O(n) insert/remove in the middle (elements shift), and compact memory. LinkedList is a doubly linked list: O(1) add/remove at the ends or at an iterator, but O(n) get(i) and much higher memory overhead. In practice ArrayList wins almost always; use ArrayDeque for queues and stacks.

Comparable<T> is implemented by the class itself (compareTo) and defines its single natural order. A Comparator<T> is a separate object defining any order, built easily with Comparator.comparing(...).thenComparing(...).reversed(). Use Comparable for an obvious natural order, and comparators for everything else.

Iterators of most collections (ArrayList, HashMap) throw ConcurrentModificationException if the collection is structurally modified during iteration by anything other than the iterator itself:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));
        try {
            for (Integer n : nums) {
                if (n % 2 == 0) nums.remove(n);
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("ConcurrentModificationException");
        }
        nums.removeIf(n -> n % 2 == 0);   // the safe way
        System.out.println(nums);
    }
}

ConcurrentModificationException
[1, 3]

Concurrent collections such as CopyOnWriteArrayList and ConcurrentHashMap have fail-safe (weakly consistent) iterators instead.

Checked exceptions (subclasses of Exception but not RuntimeException, such as IOException) must be caught or declared with throws; they represent recoverable conditions the caller should consider. Unchecked exceptions (RuntimeException and subclasses such as NullPointerException and IllegalArgumentException) need not be declared; they usually indicate programming errors. Errors (such as OutOfMemoryError) are serious problems that applications should not catch.

A try (Resource r = ...) statement automatically calls close() on resources implementing AutoCloseable when the block ends, even after an exception, in reverse order of declaration. Exceptions thrown while closing are attached as suppressed exceptions to the main one. It replaces error-prone finally { close(); } code.

import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> freq = new TreeMap<>();
        for (String w : "to be or not to be".split(" ")) {
            freq.merge(w, 1, Integer::sum);
        }
        System.out.println(freq);
    }
}

{be=2, not=1, or=1, to=2}

O(n log k) with TreeMap; O(n) with HashMap if order does not matter. A stream version is Collectors.groupingBy(w -> w, Collectors.counting()).