Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
194 results across 1 active filter
Page 8 of 9
Evaluates parallel streams through workload size, splittability, CPU cost, ordering, common-pool contention, state, and measurement.
Chooses concurrent collections by required atomic operations and iteration semantics rather than treating them as synchronized replacements.
Chooses Java time types by business meaning and handles time zones, daylight-saving transitions, persistence, and testable clocks.
Distinguishes object identity from value equality and prevents fragile code based on interning or implementation accidents.
Distinguishes reference identity from logical equality and shows how nulls, strings, enums, and domain values affect the choice.
Explains monitor wait sets and guarded loops while preferring queues, latches, semaphores, futures, and conditions for standard coordination.
Compares eager collections with lazy one-pass generation through memory, timing, reuse, readability, and resource ownership.
Compares Java interfaces and abstract classes through contract, shared state, implementation reuse, and evolution trade-offs.
Compares Java list implementations using actual access patterns, traversal cost, memory locality, and insertion location.
Chooses an explicit lock only when timed, interruptible, conditional, or advanced acquisition behavior justifies manual lifecycle.
Chooses structural or nominal contracts based on ownership, runtime identity, shared behavior, and third-party integration.
Chooses among common Java map implementations by lookup behavior, iteration order, sorting, range operations, and key contracts.
Introduces lower-level allocation tools while emphasizing measurement, ownership, and safe usage.
Contrasts runtime-checked array covariance with compile-time-safe generic invariance and explains why generic arrays are restricted.
Treats raw types as a legacy compatibility boundary that can introduce heap pollution and delayed runtime failures.
Explains interference, stateful lambdas, execution-order assumptions, safe collection, and visibility of unavoidable effects.
Explain why async void is usually dangerous outside event handlers and how exceptions behave differently.
Diagnoses shared mutable function defaults and explains safe initialization without turning the behavior into a superstition.
Explains fail-fast iteration, safe removal patterns, structural modification, and why the exception is not a concurrency guarantee.
Explains generics as compile-time type-safe reuse that improves API contracts and removes scattered casts.
Explains how delegation preserves replaceable behavior and narrower coupling while recognizing valid inheritance cases.
Explains Java generic invariance through the unsafe write that subtype assignment would otherwise permit.
Separates String immutability from interning and connects both to safe sharing, equality, concatenation, and practical performance.
Connects Java's equality and hash contracts to real HashMap and HashSet behavior, including mutable-key failures.