Rehearse Java interview scenarios covering OOP, collections, multithreading, and the JVM — with camera recording and AI-powered performance analysis.
Practice with AI Interviewer →Java developer interviews focus on the language and platform — OOP principles, the collections framework, generics, multithreading, JVM internals, and modern Java features (records, sealed classes, pattern matching). Where a <a href='/interview/java-software-engineer'>Java software engineer interview</a> emphasises Spring architecture and system design, a Java developer interview tests whether you understand the language deeply enough to write correct, performant code.
Below you'll find 40-plus questions organised by the categories that appear most often in Java interview loops — from core OOP through JVM internals. Use them to practise with our AI interviewer or as a self-study checklist.
Java interview loops typically include four to five rounds. At least one round focuses on core language knowledge without any framework involvement.
Covers your Java experience, which versions you've worked with, and familiarity with the ecosystem — build tools, testing frameworks, and whether you've used Spring.
Tests OOP, the collections framework, exception handling, generics, and multithreading. Expect tricky questions on edge cases — autoboxing, equals/hashCode contracts, and concurrent modification.
Algorithm and data-structure problems solved in Java. Interviewers evaluate your use of the standard library (Streams, Collections, Optional), code structure, and handling of edge cases.
Deeper questions on garbage collection, memory model, class loading, and JVM tuning. More common at mid-to-senior levels.
Focuses on working in Java-heavy enterprise environments, debugging production issues, and collaborating with large teams.
Java behaviorals focus on how you work in enterprise environments, debug complex issues, and make pragmatic decisions in large codebases.
The foundation of every Java interview. Interviewers use these questions to test whether you understand Java's type system, collection contracts, and OOP principles beyond textbook definitions.
Concurrency is Java's signature interview topic. Interviewers test whether you can write thread-safe code and reason about the Java Memory Model — not just use synchronized blocks.
Identify the shared state — What data is accessed by multiple threads, and what operations are non-atomic?
Name the concurrency risk — Race condition, deadlock, livelock, or visibility issue (stale reads).
Choose the synchronisation mechanism — synchronized, ReentrantLock, AtomicInteger, ConcurrentHashMap, or volatile — and explain why it fits.
Consider the Java Memory Model — Explain happens-before relationships if the question involves visibility.
Discuss alternatives — Could you avoid shared state entirely using immutable objects, thread-local storage, or message passing?
Mid-to-senior Java interviews probe your understanding of the runtime — garbage collection, class loading, and JVM tuning. These questions reveal whether you can debug and optimise production Java applications.
Rehearse OOP discussions, concurrency deep-dives, and coding challenges with our AI interviewer — get feedback on your Java fundamentals and communication.
Start Practising →Saying 'encapsulation hides implementation details' is grade-school Java. Interviewers want to hear when you'd choose composition over inheritance, how sealed classes change your modelling options, and why immutability matters for thread safety.
This trips up a surprising number of experienced candidates. If you override equals but forget hashCode, your objects break in HashMaps and HashSets. Interviewers use this as a litmus test for attention to language contracts.
Slapping synchronized on every method shows you know the keyword but not the trade-offs. Strong candidates choose between AtomicInteger, ConcurrentHashMap, ReentrantLock, or immutable objects based on the specific concurrency pattern.
Records, sealed classes, pattern matching, text blocks, and switch expressions are mainstream Java now. Candidates who don't know features beyond Java 8 signal they haven't kept up with the language's evolution.
Do you understand Java's type system, collection contracts, and OOP principles deeply — not just syntactically?
Can you write thread-safe code and reason about the Java Memory Model?
Do you know the JVM well enough to diagnose memory issues, GC pauses, and performance bottlenecks?
Are you current with modern Java features (17+) — records, sealed classes, pattern matching?
Can you use Java Streams, Optional, and functional patterns idiomatically?
Do you handle exceptions, null safety, and edge cases with production-level rigour?
A Java developer interview tests core language knowledge — OOP, collections, generics, multithreading, JVM internals. A Java software engineer interview adds Spring architecture, system design, microservices patterns, testing strategy, and deployment. The engineer role expects broader architectural judgment.
Java 17 is the minimum expectation as it's the current LTS. Know records, sealed classes, pattern matching, text blocks, and switch expressions. Familiarity with Java 21 features (virtual threads, sequenced collections) is a bonus that signals you're keeping current.
Very important at mid and senior levels. Expect questions on synchronized vs Lock, the Java Memory Model, CompletableFuture, and ConcurrentHashMap internals. Concurrency is Java's signature topic because the language has rich, complex threading support.
Not for pure Java developer roles. Spring questions appear in Java software engineer and Java backend engineer interviews. Core Java interviews focus on the language and JVM. However, mentioning Spring experience shows practical relevance.
OOP (equals/hashCode, inheritance vs composition), collections (HashMap internals, ConcurrentHashMap), generics (type erasure), multithreading (synchronized vs Lock, CompletableFuture), and garbage collection. Streams and modern Java features follow closely.
Only if the job listing mentions it. Pure Java interviews test Java. However, understanding Kotlin's interoperability with Java and why companies adopt Kotlin (null safety, coroutines, conciseness) shows you're aware of the JVM ecosystem's direction.
Increasingly tested at mid-to-senior levels. You should understand heap vs metaspace, GC algorithms (G1 vs ZGC), and basic JVM flags. You don't need to be a performance engineer, but you should know how to diagnose OutOfMemoryErrors and GC pauses.
Moderate to hard. Java has significant complexity — generics with type erasure, the Java Memory Model, GC algorithms, and a large standard library. Interviews target these areas specifically because they separate developers who understand the platform from those who just use the syntax.
Rehearse OOP discussions, concurrency deep-dives, and coding challenges with our AI interviewer.
Start a Mock Interview →Takes less than 15 minutes.