Common Java Developer Interview Mistakes & Solutions

// A correct equals/hashCode implementation — the classic interview example
// (and a common place candidates lose credibility)

import java.util.Objects;

public final class Employee {
    private final long id;
    private final String email;

    public Employee(long id, String email) {
        this.id = id;
        this.email = email;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee)) return false;
        Employee other = (Employee) o;
        return id == other.id && Objects.equals(email, other.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, email);
    }

    // Why this matters:
    // If you put Employee objects in a HashSet and don't override both,
    // you'll get "duplicates" that aren't really duplicates.
    // HashMap lookups can fail for logically equal objects.
    // This is a fundamental — every Java interviewer tests it.

// Choosing the right collection — the follow-up question
// (candidates who say "ArrayList" for everything lose points)

import java.util.*;

public class CollectionChoice {
    public static void main(String[] args) {
        // 1. Ordered, indexed, fast random access → ArrayList
        List<String> names = new ArrayList<>();

        // 2. Fast membership checks, no ordering needed → HashSet
        Set<String> uniqueEmails = new HashSet<>();

        // 3. Key-value lookups, no ordering → HashMap
        Map<Long, String> userById = new HashMap<>();

        // 4. Sorted iteration → TreeMap
        Map<Long, String> sortedById = new TreeMap<>();

        // 5. Thread-safe map (better than Hashtable) → ConcurrentHashMap
        Map<Long, String> safeMap = new ConcurrentHashMap<>();

        // 6. FIFO processing → ArrayDeque as a queue
        Deque<String> queue = new ArrayDeque<>();
        queue.offer("job-1");
        queue.offer("job-2");
        String next = queue.poll();

        // 7. LIFO processing → ArrayDeque as a stack
        Deque<String> stack = new ArrayDeque<>();
        stack.push("a");
        stack.push("b");
        String top = stack.pop();

        // Interview tip: always say WHY you chose the collection,
        // not just which one you used.
    }
}

// Three ways to build a thread-safe counter
// (a common interview warm-up that separates candidates)

import java.util.concurrent.atomic.AtomicLong;

// 1. synchronized — simplest, but blocks on every call
public class SyncCounter {
    private long count = 0;
    public synchronized void increment() { count++; }
    public synchronized long get() { return count; }
}

// 2. AtomicLong — lock-free, best for simple counters
public class AtomicCounter {
    private final AtomicLong count = new AtomicLong(0);
    public void increment() { count.incrementAndGet(); }
    public long get() { return count.get(); }
}

// 3. LongAdder — highest throughput under contention
import java.util.concurrent.atomic.LongAdder;
public class AdderCounter {
    private final LongAdder count = new LongAdder();
    public void increment() { count.increment(); }
    public long get() { return count.sum(); }
}

// Interview follow-up: "Which would you use?"
// - Low contention, simple counter → AtomicLong
// - High contention, many threads → LongAdder
// - Complex invariants → synchronized (or ReentrantLock)
// Explaining the trade-off is what interviewers want.

// ExecutorService — how real Java apps use threads
// (never create raw threads in production code)

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

public class TaskProcessor {
    public static void main(String[] args) throws InterruptedException {
        // Fixed pool of 4 threads — suitable for CPU-bound work
        ExecutorService executor = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println(
                    Thread.currentThread().getName() +
                    " processing task " + taskId
                );
                // Do work here
            });
        }

        executor.shutdown();
        executor.awaitTermination(30, TimeUnit.SECONDS);

        // Key interview points:
        // - Use thread pools, not raw threads
        // - Match pool size to task type (CPU-bound vs I/O-bound)
        // - Always shut down the executor
        // - Use CompletableFuture for async composition
    }
}