Core Java

Tests whether you know all four flavors and what specifically distinguishes each one's scope and use case.

Tests whether you know a static nested class doesn't hold an implicit reference to an instance of the outer class, unlike a regular inner class.

Tests whether you know a local inner class can only capture effectively final local variables from its enclosing scope.

Tests whether you know when this one-off, no-name class syntax is appropriate versus when a lambda or named class fits better.

Tests whether you know exactly which memory regions each GC type actually sweeps.

Tests whether you know these are triggered by two completely different memory regions filling up.

Tests whether you know the pause-time and throughput tradeoffs across modern collectors, not just their names.

Tests whether you recognize this as the classic memory-leak signature and know the heap-dump workflow to isolate it.

Tests whether you know Metaspace exhaustion usually points to classloader leaks, not regular object allocation.

Tests whether you know to look past the heap entirely — direct ByteBuffers, Netty off-heap memory, or JNI leaks.

Tests whether you know JVM safepoints (biased lock revocation, deoptimization) can freeze threads independently of GC.

Tests whether you know the JIT can allocate objects on the stack instead of the heap when it proves they never escape a method.

Tests whether you know why a class request always goes up the classloader hierarchy first, and what that prevents.

Tests whether you know the practical workflow: dominator tree, retained size, and finding the actual leak suspect.

Tests whether you know how the JVM avoids lock contention on every single object allocation.

Tests whether you know the JVM picks sensible defaults based on hardware and heap size without any flags at all.

Tests whether you know the heap, stack, metaspace, and PC register layout and what lives where.

Tests whether you understand generational GC, reachability, and why Java doesn't need manual memory management.

Tests whether you know why a class request is always delegated upward first, and what that prevents.

Tests whether you know these three reference types and how each affects when the GC is allowed to reclaim an object.

Tests whether you understand how the JVM detects hot code paths and compiles them to native machine code at runtime.

Tests whether you understand the three nested layers of the Java platform and what each one is actually responsible for.

Checks whether you can explain encapsulation, abstraction, inheritance, and polymorphism with concrete examples, not just definitions.

Tests your understanding of reference equality versus logical equality, and where each one silently trips people up.

Tests whether you know compile-time vs runtime polymorphism and the rules that govern each.

Tests whether you know when to use each, especially after Java 8 added default and static methods to interfaces.

Tests whether you understand what 'belongs to the class, not the instance' actually means in memory and execution order.

A classic trick question — tests whether you know Java is always pass-by-value, even for objects, and why that still confuses people.

Tests whether you know how Java silently converts between primitives and wrapper classes, and where that costs performance.

Tests whether you understand multiple inheritance ambiguity and the specific resolution rules Java applies for default methods.

Tests whether you know the classic instanceof check plus the newer syntax that eliminates the redundant cast afterward.

Tests whether you know binary data needs byte streams while text data is better handled by character-aware Reader/Writer classes.

Tests whether you know buffering reduces the number of expensive underlying I/O calls by reading in larger chunks.

Tests whether you know NIO's channel/buffer model and selectors enable non-blocking I/O that classic java.io can't do.

Tests whether you know try-with-resources guarantees close() is called correctly even when multiple exceptions occur, which manual finally blocks often get wrong.

Tests whether you know an enum is really a special class with a fixed set of singleton instances, not just a list of named integers.

Tests whether you know enums are full classes that can carry state and even constant-specific method bodies.

Tests whether you know enums give you type safety and namespace clarity that plain int or String constants don't.

Tests whether you know the actual design reasons (security, caching, thread safety) behind one of Java's most quoted facts.

Tests whether you understand where string literals actually live in memory and why that affects == comparisons.

Tests whether you know the mutability and thread-safety tradeoffs behind these three near-identical-looking classes.

A classic string DSA problem testing whether you can move from brute force to an efficient expand-around-center or DP approach.

Tests whether you can apply the sliding-window technique correctly to a genuinely tricky two-pointer problem.

Tests whether you know synchronized blocks and native calls can pin a virtual thread to its carrier thread.

Tests whether you know how it ties a group of subtasks' lifetimes together for cleaner cancellation and error handling.

Tests whether you know an unhandled exception in a chain just completes the future exceptionally, with nothing logged unless you check.

Tests whether you know thread-safety of individual operations doesn't make compound check-then-act sequences atomic.

Tests whether you know excessive threads can increase context-switching overhead and contention beyond a certain point.

Tests whether you know the tradeoffs in fairness, interruptibility, and read/write optimization across the three.

Tests whether you know these three synchronization tools solve genuinely different coordination problems.

Tests whether you know work-stealing is what makes ForkJoinPool efficient for divide-and-conquer tasks specifically.

Tests whether you know the four built-in RejectedExecutionHandler strategies and when each is appropriate.

Tests whether you know these overlapping-sounding terms actually describe two distinct classes of concurrency bug.

Tests whether you know pooled threads never die, so a ThreadLocal never cleared keeps leaking across every reused thread.

Tests whether you understand shared vs isolated memory space and why threads are cheaper to create.

Tests whether you understand Java's low-level thread coordination primitives and the monitor lock they require.

Tests whether you know the four necessary conditions for deadlock and practical strategies to avoid them.

Tests whether you know volatile guarantees visibility, not atomicity — one of the most commonly misunderstood keywords.

Tests whether you know why managed thread pools beat manually creating and managing Thread objects in production code.

Tests whether you can correctly write the volatile + double-checked-locking pattern, a classic concurrency coding question.

Tests whether you understand the formal rules that govern visibility and ordering across threads — deep concurrency territory.

Tests whether you know how to chain and combine async operations rather than blocking with Future.get().

Tests whether you know the fixed-size-vs-dynamic and primitive-vs-object tradeoffs between the two.

Tests whether you know the classic O(n) dynamic programming trick, not just a brute-force O(n²) scan.

Tests whether you can sort in a single O(n) pass with three pointers instead of a generic sort or two passes.

A well-known hard array problem testing two-pointer or prefix-max/suffix-max thinking under a tricky constraint.

Tests whether you know both the O(n²) DP solution and the O(n log n) patience-sorting-based approach.

Tests whether you have a clear mental map of Java's core collection interfaces and how they relate to each other.

One of the most-asked Java questions — tests whether you actually understand hashing, bucket placement, and collision resolution, not just usage.

Tests whether you know the thread-safety, null-key, and performance differences between these two legacy-adjacent classes.

Tests whether you know to check hashCode() quality, load factor, and whether entries are treeifying due to collisions.

Tests whether you understand segment/bucket-level locking and why it beats simply synchronizing a whole HashMap.

Tests whether you know why ConcurrentModificationException happens and which collections avoid it, and how.

Tests whether you know a changed hashCode() after insertion makes the entry effectively unfindable at its original bucket.

Tests whether you know every single write copies the entire underlying array, which is brutal for write-heavy or large lists.

A very common coding-round question testing whether you know LinkedHashMap's access-order mode and removeEldestEntry hook.

Tests whether you understand the resize trigger, the doubling behavior, and why rehashing is expensive.

Tests whether you know this exception is about structural modification during iteration, not literally about concurrent threads.

Tests whether you can weigh whole-map locking against ConcurrentHashMap's finer-grained concurrency for the actual access pattern.

Tests whether you know a constant or low-quality hashCode collapses lookups from O(1) toward O(n) by funneling everything into one bucket.

Tests whether you know ConcurrentHashMap guarantees the mapping function runs atomically per key, avoiding duplicate computation.

Tests whether you know EnumMap uses ordinal-based array indexing instead of general-purpose hashing.

Tests whether you know to pair a frequency HashMap with a bounded PriorityQueue instead of sorting everything.

Tests whether you know WeakHashMap lets the garbage collector reclaim entries whose keys have become otherwise unreachable.

Tests whether you can name and briefly explain lambdas, streams, Optional, and the new Date/Time API.

Tests whether you understand the single-abstract-method rule that makes lambda expressions possible.

Tests whether you understand when a stream operation needs to flatten nested structures, not just transform elements.

Tests whether you know how to use Optional correctly, and the common anti-patterns that misuse it.

Tests whether you understand that intermediate operations don't execute until a terminal operation triggers the pipeline.

Tests whether you know which exceptions the compiler forces you to handle and why that distinction exists.

Tests whether you know how AutoCloseable resources get closed automatically, and in what order during suppressed exceptions.

Tests whether you can design exception classes correctly and know when each type is the right choice.

Tests whether you know how to preserve the original cause when wrapping and rethrowing a different exception type.

Tests whether you know these are thrown at different times for different reasons, despite sounding like the same problem.

Tests whether you know records give you shallow immutability for their own fields, not deep immutability of referenced objects.

Tests whether you know sealed types let you declare an exhaustive, closed set of permitted subtypes at compile time.

Tests whether you know how it eliminates the manual instanceof-and-cast boilerplate switch statements used to require.

Tests whether you know this new interface finally gives a consistent way to access first/last elements across ordered collection types.

Tests whether you understand the mechanism that lets thousands of virtual threads share a small pool of OS carrier threads.

Tests whether you know var is fine when the type is obvious from context, but can obscure intent when it isn't.

Tests whether you're current on recent JVM changes and know what shrinking object headers actually saves in practice.

Tests whether you can recognize when a shrinking/growing window beats a brute-force nested loop.

Tests whether you know how converging pointers from both ends of a sorted structure eliminate redundant comparisons.

Tests whether you know Floyd's algorithm and why two pointers moving at different speeds must eventually meet in a cycle.

Tests whether you know to sort by start time first, then merge in a single linear pass.

Tests whether you know a bounded heap gets you the top K in O(n log k) instead of paying for a full O(n log n) sort.

Tests whether you can recognize the include-or-exclude decision structure that generalizes to many DP problems.

Tests whether you know how to order nodes in a DAG so every dependency is processed before what depends on it.

Tests whether you know to maintain a fixed-size min-heap instead of re-sorting on every new element.

Tests whether you can design a harder variant of LRU that also tracks access frequency, not just recency.

Tests whether you know the two-heap technique (a max-heap and a min-heap balanced against each other) for this classic problem.

Tests whether you know to model this as a graph shortest-path problem and solve it with BFS.

One of the most common coding-round openers — tests whether you can manipulate pointers correctly without losing the list.

Tests whether you know Floyd's cycle detection (slow/fast pointer) technique.

Tests whether you can combine a hash map and a doubly linked list to get O(1) get/put with eviction.

Tests whether you can implement preorder, inorder, postorder, and level-order traversal, iteratively and recursively.

Tests whether you know the common mistake of only checking immediate children instead of the full valid range.

Tests whether you can implement the classic priority-queue-based shortest path algorithm and explain its greedy correctness.

Tests whether you know how to order a DAG's nodes using DFS-based or Kahn's BFS-based approach.

Tests whether you can implement Singleton correctly and know the ways it can accidentally be broken.

Tests whether you know when a growing list of constructor parameters should become a Builder instead.

Tests whether you can name and briefly explain all 5 SOLID principles with a one-line example each.