Interview questions by language
The JVM, garbage collection, collections, concurrency, and modern language features.
What it really tests
A Java interview tests three layers at once: the language, the JVM beneath it, and the standard collections you will use every day. At the language level interviewers check that you understand the difference between primitives and objects, how == differs from .equals(), and the contract between equals() and hashCode(). At the JVM level they probe garbage collection, the memory model, and what 'write once, run anywhere' actually buys you. And at the library level they expect fluent use of the Collections framework, because almost every real Java problem touches a List, Map, or Set.
Because Java is everywhere in enterprise and fintech, the bar for correctness is high and the bar for surprises is low: interviewers want safe, predictable, well-typed code. That shows up in questions about immutability (why String is immutable, how to build immutable classes), exception handling (checked vs unchecked, try-with-resources), and the equals/hashCode contract that, if broken, silently corrupts hash-based collections.
Senior Java interviews lean hard on concurrency and the JVM. You should be able to discuss the volatile keyword and the happens-before relationship, the difference between synchronized and the java.util.concurrent toolkit, and how the garbage collector (G1, ZGC) trades throughput for pause time. A candidate who can explain why a HashMap is not thread-safe and what ConcurrentHashMap does instead is signalling production experience.
Java is the backbone of enterprise, fintech, and large-scale backend hiring across the US and EU; expect it in backend, platform, and Android (with Kotlin) loops, often with deep JVM and concurrency questions for senior roles.
The map
== vs .equals(), the equals/hashCode contract, why String is immutable, and how to design an immutable class. Breaking the contract corrupts HashMap and HashSet.
When to use ArrayList vs LinkedList, HashMap vs TreeMap, and the performance characteristics of each. This is the most-used part of the language and the most-asked.
Heap vs stack, generational GC, and the modern collectors (G1, ZGC) and their pause-time tradeoffs. The JVM is what makes Java questions deeper than C#.
synchronized, volatile, the happens-before model, and the java.util.concurrent classes (ConcurrentHashMap, ExecutorService, atomics). Senior loops dwell here.
Question bank
The questions that come up most often, each with a sample answer you can adapt into your own words. Read them out loud until the explanation feels natural.
== compares references for objects (whether two variables point to the same object) and values for primitives. .equals() compares logical equality as defined by the class; the default Object.equals() is reference equality, but classes like String and Integer override it to compare contents. So for two distinct String objects with the same characters, == may be false while .equals() is true.
If two objects are equal by equals(), they must return the same hashCode(). If you override equals() but not hashCode(), hash-based collections like HashMap and HashSet break: equal objects land in different buckets and lookups fail. The reverse is allowed (equal hash codes do not require equality), which is just a hash collision.
String immutability enables safe sharing through the string pool, makes strings safe to use as HashMap keys (their hash never changes), and provides thread-safety for free since the value cannot be mutated. It also supports security: a string passed to a file path or network call cannot be changed by another thread after a check. The cost is that string concatenation in a loop creates garbage, which is why you use StringBuilder.
Checked exceptions extend Exception (but not RuntimeException) and must be either caught or declared with throws; the compiler enforces handling, for recoverable conditions like IOException. Unchecked exceptions extend RuntimeException and are not enforced by the compiler; they represent programming errors like NullPointerException or IllegalArgumentException. The guideline is checked for recoverable, unchecked for bugs.
The JVM heap is split into generations: most objects are allocated in the young generation and die quickly (minor GC), and survivors are promoted to the old generation (major GC). Generational collection exploits the fact that most objects are short-lived. Modern collectors like G1 and ZGC partition the heap into regions and aim to bound pause times, trading some throughput for predictable latency.
volatile guarantees visibility: a write to a volatile field is immediately visible to other threads, and reads always fetch from main memory rather than a cached copy. It also establishes a happens-before ordering that prevents certain instruction reorderings. It does not provide atomicity for compound actions like count++, so for that you use synchronized or an atomic class.
Use ArrayList for almost everything: it has O(1) random access and better cache locality, and amortised O(1) append. LinkedList only wins when you do frequent insertions or removals at the ends or via an iterator and rarely index, but in practice ArrayList usually outperforms it even there because of memory locality. Defaulting to ArrayList is the safe answer.
HashMap is not thread-safe; concurrent modification can corrupt its internal structure or cause infinite loops in older versions. ConcurrentHashMap is thread-safe and high-throughput: it locks only a portion of the map (lock striping / per-bin synchronisation) so multiple threads can update different segments in parallel, and reads are largely lock-free. Use ConcurrentHashMap instead of wrapping HashMap with Collections.synchronizedMap when you need concurrency.
Avoid these
The plan
An external resource we recommend. Educative is not affiliated with us and we earn nothing from this link.
Apply it to a role
Keep exploring
Language fluency gets you through the screen. Pair it with the coding interview patterns, rehearse the behavioral round with worked STAR answers, and when the offer comes, check it is competitive with the salary comparison tool.