Question 1

Explain HashMap internals and how collisions are handled in Java 8+.

Accepted Answer

A lazily-created array of buckets indexed by a spread hash; collisions chain into a linked list that becomes a red-black tree only when the bin holds 8+ nodes AND the table is at least 64 slots.

Question 2

When would you use ConcurrentHashMap over synchronizedMap?

Accepted Answer

Since Java 8 there are no segments. It locks one bin at a time — a CAS to install the first node in an empty bin, and synchronized on the bin's head node otherwise — while reads never lock at all. The catch is that per-key atomicity does not make your sequence of calls atomic.

Question 3

How do Streams differ from traditional loops, and when can parallel streams hurt performance?

Accepted Answer

It runs on one ForkJoinPool shared by the whole JVM, so a slow task in one place starves parallel work everywhere else — including anything a library does. Add the usual problems of shared mutable state and non-associative reductions, and the honest default is not to use it until you have measured.

Question 4

How do virtual threads in Java 21 change concurrency and thread-pool design?

Accepted Answer

Small. Connections needed equals arrival rate times how long each request holds one, so a pool of ten usually beats a pool of a hundred — past the point where the database can run more statements at once, extra connections add contention, not throughput. The number that decides everything is hold time, and the fastest way to ruin a pool is to hold a connection across a call you do not control.

Question 5

Explain happens-before, volatile and atomic operations in concurrent Java code.

Accepted Answer

A guarantee, not a statement about time: if A happens-before B, everything A wrote is visible to B. Without an edge between two threads there is no guarantee at all, whatever the clock says. The practical payoff is the opposite of what people expect — most fields crossing an existing edge need no volatile.

Question 6

Explain Spring IoC, bean scopes and the lifecycle of a singleton bean.

Accepted Answer

Constructor injection makes the dependency list part of the type, so a bean cannot be built wrong, its fields can be final, and a cycle fails immediately. Field injection wires in a second phase after construction, which is why it hides both a missing dependency and a circular one until something calls the method.

Question 7

Explain @Transactional propagation, isolation and common rollback pitfalls.

Accepted Answer

Spring wraps your bean in a proxy that opens a transaction before the method and commits after. Everything surprising follows from that: a self-invoked call bypasses the proxy entirely, and a checked exception commits instead of rolling back.

Question 8

How does Spring AOP work, and why can self-invocation bypass advice?

Accepted Answer

Spring builds a proxy around your bean — a JDK dynamic proxy if it has an interface, a generated subclass otherwise — and the advice lives in the proxy, not in your class. Every limit follows: self-invoked, private, final and static methods never cross the proxy, so an annotation on them does nothing and nothing warns you.

Question 9

How would you design global REST exception handling and API validation?

Accepted Answer

Checked exceptions are enforced by the compiler; unchecked ones are not. The interesting question is not the definition but why every major Java framework since 2004 has moved to unchecked exceptions — and lambdas finished the argument in Java 8.

Question 10

How would you configure resilience using timeouts, retries, circuit breakers and bulkheads?

Accepted Answer

It stops calling a dependency that is clearly failing, so the caller fails fast instead of queueing behind a timeout. Three states — and the half-open one is the whole design, because it is how the breaker finds out the dependency recovered without letting all the traffic back in at once.

Question 11

How would you handle distributed transactions without using two-phase commit?

Accepted Answer

Four levels, defined by which anomalies they allow rather than by how they are built: read uncommitted permits dirty reads, read committed permits non-repeatable reads, repeatable read permits phantoms, serializable permits none. The table is about reads — the anomaly that actually loses money, the lost update, is not in it, and your database's default is probably weaker than you assume.

Question 12

Find the first non-repeating character in a String using Java Streams.

Accepted Answer

They build almost the same thing and fail completely differently. toMap throws IllegalStateException on a duplicate key and NullPointerException on a null value; groupingBy does neither, because a group is a list and a list can hold anything. Both defaults are choices, and toMap's are the ones that reach production.

Question 13

Merge overlapping intervals efficiently and return the consolidated ranges.

Accepted Answer

Dual-pivot quicksort for primitives, TimSort for objects. The split is not about speed — it is that objects can be distinguishable while comparing equal, so their sort has to be stable, and primitives cannot be, so theirs is free to sort in place.

Question 14

Implement a thread-safe LRU cache with O(1) get and put operations.

Accepted Answer

Since Java 8 there are no segments. It locks one bin at a time — a CAS to install the first node in an empty bin, and synchronized on the bin's head node otherwise — while reads never lock at all. The catch is that per-key atomicity does not make your sequence of calls atomic.

Thoughtworks — Java Backend Developer

Java

Spring and Spring Boot

Microservices

Coding

What this list is worth