Loading
Pick a focused question that fits your time, stack, and interview goal.
24 results across 1 active filter
Page 1 of 1
Explains collectors as terminal reduction strategies and composes grouping, mapping, counting, and summary operations.
Explains stream sources, lazy intermediate operations, terminal execution, short-circuiting, encounter order, and single use.
Explains Java HashMap lookup through hashing, buckets, equality, collisions, resizing, and stable keys without implementation trivia.
Applies upper and lower bounded wildcards to producer and consumer APIs while explaining their limits.
Chooses a Java collection by the behavior the code needs: ordering, duplicates, membership, lookup keys, and iteration.
Makes duplicate-key behavior explicit through validation, merge policies, grouping, and deterministic map selection.
Uses Optional to model absence at return boundaries and avoids eager defaults, null Optionals, unsafe get calls, and awkward field or parameter usage.
Explains Java lambdas as implementations of single-abstract-method contracts and connects standard interfaces to API design.
Distinguishes a type's natural order from external, reusable sort strategies and connects comparison consistency to sorted collections.
Separates an unmodifiable API surface from a stable snapshot and from deep immutability of contained objects.
Distinguishes one-to-one transformation from transformation plus flattening for nested collections, streams, and optionals.
Explains how Java compiles generic code and connects erasure to runtime checks, reflection limits, overloads, arrays, and bridge methods.
Chooses streams or loops by transformation shape, control flow, side effects, debuggability, and measured performance.
Uses bounds to express capabilities required by generic code and distinguishes them from wildcard flexibility at call sites.
Evaluates parallel streams through workload size, splittability, CPU cost, ordering, common-pool contention, state, and measurement.
Compares Java list implementations using actual access patterns, traversal cost, memory locality, and insertion location.
Chooses among common Java map implementations by lookup behavior, iteration order, sorting, range operations, and key contracts.
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.
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 Java generic invariance through the unsafe write that subtype assignment would otherwise permit.
Explains Java lambda capture through copied local values, mutable referenced objects, lifetime, and safe state handling.