Advanced Java

Keep type relationships checked and preserve useful failure context.

1. 1Java generics: invariance, bounds, and type erasure
2. 2Java exceptions: recovery boundaries and failure context
3. 3Java Optional: absence without hidden failure

Express transformations without hiding shared side effects.

1. 1Java lambdas: function contracts and captured state
2. 2Java streams: lazy pipelines and bounded results

Read a bounded format and close resources on every exit path.

1. 1Java file I/O: UTF-8, streaming reads, and path ownership
2. 2Java try-with-resources: close order and suppressed failures

Define rounding, representation, local intent, and timeline identity.

1. 1Java BigDecimal: decimal amounts and explicit rounding
2. 2Java date and time: local schedules versus instants

Coordinate shared state, bound waiting work, and shut down owned workers.

1. 1Java threads: visibility, atomicity, and shared counters
2. 2Java ExecutorService: bounded admission and shutdown

State what reads metadata and respect member access.

1. 1Java annotations: retention and explicit processing
2. 2Java reflection: inspect types without breaking contracts

Inspect retaining owners before changing runtime budgets.

1. 1Java JVM memory: stack frames, heap objects, and reachability
2. 2Java garbage collection: diagnose retention before tuning

Own query resources, commit decisions, request deadlines, and response size.

1. 1Java JDBC PreparedStatement: values stay outside SQL grammar
2. 2Java JDBC transactions: atomic updates and rollback
3. 3Java HttpClient: request policy, deadlines, and response size

Use version-labelled value types, closed variants, patterns, and virtual threads.

1. 1Java records: value carriers and defensive copies
2. 2Java sealed types: restrict a domain’s direct variants
3. 3Java 21 pattern switch: exhaustive branches and null policy
4. 4Java 21 virtual threads: blocking tasks still need limits

Declare compiler targets and run contract-focused assertions.

1. 1Java Maven builds: compiler release and dependency scope
2. 2Java JUnit tests: boundary cases and observable contracts

Protect the whole invariant and define the task completion boundary.

1. 1Java atomic variables: compare-and-set and one-variable invariants
2. 2Java ReentrantLock: protect a complete state transition
3. 3Java CompletableFuture: composition, failures and executor ownership

Bound byte transfers and separate startup effects from ordinary calls.

1. 1Java byte streams: partial reads and bounded copying
2. 2Java class initialization: static state and failure timing

Inspect loaders, modules and recording artifacts.

1. 1Java class loaders: type identity, delegation and initialization
2. 2Java modules: readability, exports and reflection boundaries
3. 3Java Flight Recorder: a bounded recording and a checked artifact

Protect predicates and own admission, deadlines and shutdown.

1. 1Java conditions: protected predicates and timed waiting
2. 2Java semaphores: permit accounting and bounded access
3. 3Java scheduled tasks: delay semantics and failed repetitions
4. 4Java cancellation: timed waits and cooperative interruption

Handle partial transfers and explicit record boundaries.

1. 1Java file channels: buffer positions and partial transfers
2. 2Java sockets: connection deadlines, framing and stream ownership

Verify builds and checked tests before interpreting measurements.

1. 1Java Gradle multi-project build: source ownership and a verified application task
2. 2Java test boundaries: injected collaborators and behavior-focused checks
3. 3Java parameterized tests: boundary cases without arithmetic overflow
4. 4Java JMH benchmarks: consumed results, fixtures and limited measurements

Use checked language and library contracts at their declared release.

1. 1Java 25 scoped values: request context with a bounded lifetime
2. 2Java stream gatherers: batching and ordered running totals
3. 3Java 25 constructor validation before superclass initialization
4. 4Java 25 module imports: source names without a deployment shortcut
5. 5Java 25 compact source files: an instance main with explicit input limits
6. 6Java 25 virtual threads and monitors: version boundaries still matter

Verify multi-structure ownership, retained state and operation outcomes.

1. 1Java multi-map invariants: one lock for a reservation boundary
2. 2Java heap diagnostics: retained objects, histograms and a controlled dump
3. 3Java JFR incident evidence: outcome events and failure counts

Check session visibility, pool saturation and migration history.

1. 1Java JDBC isolation: uncommitted writes and separate sessions
2. 2Java connection pools: borrowed handles, rollback and admission timeout
3. 3Java versioned data changes: checksums and a committed ledger

Check accepted input, ownership and failure behavior with the complete program.

1. 1Java foreign memory: arena lifetime, bounds and thread ownership
2. 2Java VarHandle: atomic transitions and explicit access modes
3. 3Java ServiceLoader: provider configuration and lazy discovery
4. 4Java Properties: validate configuration before changing application state
5. 5Java annotation processing: reject invalid declarations during compilation
6. 6Java LongAdder: striped counters and the limits of sum snapshots

Check accepted input, ownership and failure behavior with the complete program.

1. 1Java SwingWorker: background work and event-thread publication

Test exact boundaries, resource ownership and bounded work.

1. 1Java Spliterator: split traversal without inventing characteristics
2. 2Java toMap: reject or merge duplicate keys deliberately
3. 3Java Stream.close: terminal traversal does not close every source
4. 4Java ThreadLocal: clear request state on reused worker threads
5. 5Java bounded executors: test saturation and rejected work
6. 6Java SecureRandom: token entropy, encoding and comparison boundaries

Inspect the state boundary and run its checked fixture.

1. 1Java UTF-8 decoding: reject malformed bytes before parsing
2. 2Java DecimalFormat: reject trailing input and pin the locale
3. 3Java serialization filters: constrain classes and object graphs
4. 4Java shared Arena: coordinate access before closing memory
5. 5Java Phaser: deregister workers so a phase can complete

Follow the input contract, inspect failures and run the checked source.

1. 1Java native Linker: declare a C call and reject undefined input
2. 2Java Flow: request items and observe publisher completion
3. 3Java ByteBuffer byte order: decode the protocol before reading integers
4. 4Java CRC32: detect a byte change without claiming authenticity
5. 5Java MessageFormat apostrophes: keep placeholders visible to the parser
6. 6Java CountDownLatch: completion counting does not count successful work
7. 7Java records with arrays: copy on input and output

Run the checked fixture, then inspect its ownership and failure boundary.

1. 1Java Thread.interrupted clears the current thread’s signal
2. 2Java CompletableFuture.allOf: completion barrier, not typed results
3. 3Java CompletableFuture handle versus whenComplete: recovery is explicit
4. 4Java Files.walk: close the stream that owns directory handles

Read the contract, run the fixture, and check the failure boundary.

1. 1Java BigDecimal equality: value and scale are separate contracts
2. 2Java BlockingQueue drainTo: batch size is not a transaction
3. 3Java CompletableFuture timeout: completion is not worker cancellation
4. 4Java Files.move: atomic publication is a filesystem contract

Track node ownership, failure cases and checked resource limits.

1. 1Java generic varargs: audit the hidden array before using SafeVarargs
2. 2Java ExecutorCompletionService: consume finished tasks, not submission order
3. 3Java CallerRunsPolicy: a full worker queue moves work onto the submitter
4. 4Java Path.normalize: reject lexical escapes without promising symlink safety

Track encounter order, write-through views, copies, and mutation ownership.

1. 1Java 21 LinkedList.reversed: write-through order and endpoint edits
2. 2Java 21 List endpoint methods: availability is not mutability
3. 3Java 21 LinkedHashMap.putFirst and putLast for explicit key order
4. 4Java 21 SequencedMap.reversed: edits through a reverse-ordered map view
5. 5Java 21 LinkedHashSet.addFirst and addLast relocate existing elements
6. 6Java 21 Deque.reversed: translate head and tail mutations
7. 7Java 21 access-order LinkedHashMap: reads change a reversed view

Reject short records, malformed text, unbounded expansion, and shared-buffer surprises.

1. 1Java InputStream short reads: assemble a complete record header
2. 2Java readNBytes: reject a truncated payload after the header
3. 3Java DataInputStream.readFully: EOF can leave partial bytes in the buffer
4. 4Java CharsetDecoder: reject malformed UTF-8 instead of replacing bytes
5. 5Java ByteBuffer flip and compact: preserve an incomplete frame
6. 6Java WritableByteChannel short writes: drain the ByteBuffer
7. 7Java ZIP entry extraction: cap expanded bytes while reading
8. 8Java bounded line reader: reject oversized records without buffering the file
9. 9Java InputStream.available is not the remaining stream length
10. 10Java ByteBuffer.slice: shared storage and independent cursors

Separate elapsed time, civil schedules, precision, and zone-offset validation.

1. 1Java Duration versus Period across a daylight-saving change
2. 2Java ZonedDateTime zone conversion: preserve the instant or the wall clock
3. 3Java OffsetDateTime equality versus isEqual for event timestamps
4. 4Java YearMonth.atEndOfMonth: calculate a month boundary without guessed days
5. 5Java DateTimeFormatter week-year Y versus calendar year u
6. 6Java Instant toEpochMilli: detect lost submillisecond precision
7. 7Java LocalDate half-open ranges: define an exclusive end
8. 8Java ZoneRules: validate a saved offset against a local booking
9. 9Java negative Duration fields: seconds and nanos are normalized
10. 10Java plusMonths at month end: prevent renewal-date drift

Validate optimistic reads, coordinate phase failure, and keep cancellation and task errors observable.

1. 1Java StampedLock optimistic reads: validate before publishing state
2. 2Java ReentrantReadWriteLock downgrade: publish then keep a read lock
3. 3Java AtomicStampedReference: reject a stale A-to-B-to-A update
4. 4Java CyclicBarrier timeout: a broken generation needs a recovery rule
5. 5Java SynchronousQueue: a handoff has no storage capacity
6. 6Java volatile counter: visible writes can still lose an update
7. 7Java ConcurrentHashMap.compute: serialize one key’s remapping
8. 8Java lockInterruptibly: cancel a worker waiting for ownership
9. 9Java Condition.await: recheck the predicate after every signal
10. 10Java uncaught exception handler: observe a failed raw thread

Track the actual API result, failure policy, and resource owner.

1. 1Java walkFileTree: visit failures without hiding incomplete scans
2. 2Java WatchService: register, consume, and reset each key
3. 3Java WatchService OVERFLOW: reconcile against directory state
4. 4Java DirectoryStream: close iteration and reject silent truncation
5. 5Java symbolic links: inspect attributes without claiming race safety

Track the actual API result, failure policy, and resource owner.

1. 1Java JDBC batches: inspect update counts and own rollback
2. 2Java ResultSet: cursor position and SQL NULL are separate states
3. 3Java JDBC generated keys: validate one insert and one returned identity
4. 4Java JDBC fetch size: a hint, not a memory guarantee

Track the actual API result, failure policy, and resource owner.

1. 1Java ProcessBuilder: pass command tokens without a shell
2. 2Java Process.waitFor timeout: terminate and reap the owned child

Follow the API contract through ownership, failure, and cost.

1. 1Java HTTP query values: encode data without changing URI structure
2. 2Java HttpClient redirects: check the next origin before resending
3. 3Java HttpClient deadlines: separate connection and request timeouts
4. 4Java streaming HTTP bodies: close the stream and cap retained bytes
5. 5Java Retry-After: parse a bounded server delay without inventing a retry
6. 6Java HttpClient cookies: make session storage an owned policy

Follow the API contract through ownership, failure, and cost.

1. 1Java RecursiveTask: split work only above a measured threshold
2. 2Java ForkJoinPool: own a custom pool and its shutdown
3. 3Java ManagedBlocker: declare a rare blocking wait to the pool
4. 4Java fork/join failures: one failed task does not roll back sibling work
5. 5Java parallel streams: reduce values instead of mutating shared results

Track partial results, resource ownership, and what each observation proves.

1. 1Java FileChannel.write: finish the buffer before reporting success
2. 2Java positioned FileChannel.read: detect a short record without moving the cursor
3. 3Java FileChannel.transferTo: verify the byte count on every pass
4. 4Java FileChannel.force: distinguish written bytes from forced storage
5. 5Java FileLock: coordinate one byte range with a shared protocol
6. 6Java FileChannel.truncate: cut only after validating the recovery offset
7. 7Java AsynchronousFileChannel: own the buffer through completion

Track partial results, resource ownership, and what each observation proves.

1. 1Java ThreadMXBean deadlocks: diagnose platform-thread cycles
2. 2Java ThreadMXBean CPU time: check support and the disabled state
3. 3Java MemoryMXBean: read used, committed, and an optional maximum
4. 4Java ClassLoadingMXBean: separate live classes from lifetime totals

Choose input, output, external-access, and failure limits.

1. 1Java DOM parsing: deny external XML access at the factory
2. 2Java StAX: pull XML events under a count and entity policy
3. 3Java XPath: compile a fixed selection, not user-supplied code
4. 4Java XML Schema validation: use a trusted schema without external fetches
5. 5Java XML Transformer: bound serialized output and external access
6. 6Java XML namespaces: select by URI and local name

Choose input, output, external-access, and failure limits.

1. 1Java GZIPInputStream: cap bytes after decompression
2. 2Java GZIPOutputStream: close before using the compressed bytes
3. 3Java ZipFile entries: reject duplicate names before selection
4. 4Java ZIP CRC32: detect corruption without claiming authenticity
5. 5Java ZipOutputStream: close each entry and the archive before publication

Define visibility, ownership, handoff, and report boundaries.

1. 1Java ConcurrentHashMap.computeIfAbsent: create a counter once per key
2. 2Java ConcurrentSkipListMap: inspect an ordered time window
3. 3Java CopyOnWriteArrayList: dispatch against a listener snapshot
4. 4Java AtomicReference: publish one immutable map snapshot

Define visibility, ownership, handoff, and report boundaries.

1. 1Java DelayQueue: release retry work only after its deadline
2. 2Java Exchanger: swap buffers at a two-party rendezvous
3. 3Java LinkedTransferQueue: wait until a consumer receives work

Define visibility, ownership, handoff, and report boundaries.

1. 1Java LongAccumulator: track a concurrent high-water mark
2. 2Java ThreadLocal: restore request context when a pooled thread is reused
3. 3Java LockSupport: park only inside a checked condition loop

Keep type, dispatch, and metadata contracts explicit.

1. 1Java generic wildcards: copy from a producer into a consumer
2. 2Java type erasure: validate elements with an explicit Class token
3. 3Java bridge methods: preserve overrides after generic erasure

Keep type, dispatch, and metadata contracts explicit.

1. 1Java interface defaults: resolve a two-parent method conflict
2. 2Java compact record constructors: normalize before field assignment
3. 3Java instanceof patterns: keep a narrowed value inside its valid scope
4. 4Java switch expressions: return one value from every state
5. 5Java sealed hierarchies: switch over permitted request kinds

Keep type, dispatch, and metadata contracts explicit.

1. 1Java annotation retention: expose metadata without pretending it enforces policy
2. 2Java repeatable annotations: read every declared routing label
3. 3Java enum constant bodies: keep each fee rule with its tier

Keep database feature, row, and transaction boundaries explicit.

1. 1Java JDBC savepoints: roll back one optional step inside a transaction
2. 2Java JDBC query timeout: bound a statement without claiming a whole-request deadline
3. 3Java JDBC read-only mode: use the hint without treating it as authorization

Keep database feature, row, and transaction boundaries explicit.

1. 1Java JDBC setNull: bind a nullable column with its SQL type
2. 2Java JDBC ResultSet binary streams: read before advancing the cursor
3. 3Java JDBC binary parameters: cap bytes before binding a BLOB

Keep database feature, row, and transaction boundaries explicit.

1. 1Java SQLWarning: inspect nonfatal database diagnostics before reuse
2. 2Java DatabaseMetaData: check features before depending on them
3. 3Java JDBC cursor holdability: choose what commit does to a ResultSet
4. 4Java SQLException chains: preserve SQLState and linked failures

Track completion, failure, and resource ownership.

1. 1Java thenCompose: flatten a dependent asynchronous request
2. 2Java thenCombine: join two independent results without serializing them

Track completion, failure, and resource ownership.

1. 1Java applyToEither: use the first normal result of two stages
2. 2Java exceptionallyCompose: recover with another asynchronous stage

Track completion, failure, and resource ownership.

1. 1Java CompletableFuture join versus get: preserve failure and interruption contracts
2. 2Java CompletableFuture cancellation: distinguish result status from worker interruption

Track completion, failure, and resource ownership.

1. 1Java ExecutorService invokeAll: wait for a bounded batch with a deadline
2. 2Java ExecutorService invokeAny: return one successful result from competing tasks

Check invocation, discovery, and module contracts.

1. 1Java reflection: separate an invoked method failure from lookup failure
2. 2Java getMethod: resolve an overload by its exact parameter types
3. 3Java MethodHandle.invokeExact: make the call-site type part of the contract

Check invocation, discovery, and module contracts.

1. 1Java trySetAccessible: handle a denied deep-reflection request
2. 2Java modules: distinguish exported APIs from open packages

Check invocation, discovery, and module contracts.

1. 1Java dynamic proxies: define Object-method behavior explicitly
2. 2Java ServiceLoader: treat provider discovery as fallible startup work
3. 3Java Class.forName: inspect an allowlisted class without initializing it

Track collection views, capacity, and mutation ownership.

1. 1Java BitSet: distinguish logical length, capacity, and set-bit count
2. 2Java BitSet nextSetBit: scan a bounded index range without walking gaps
3. 3Java EnumSet complementOf: derive a default-deny capability set
4. 4Java EnumSet: retain element type when a source collection is empty
5. 5Java NavigableSet subSet: account for a live backed range

Track collection views, capacity, and mutation ownership.

1. 1Java PriorityBlockingQueue: add an admission limit to an unbounded priority queue
2. 2Java CopyOnWriteArraySet: publish against a stable listener snapshot
3. 3Java LinkedBlockingDeque: bound urgent and normal work in one queue

Failure cases and API contracts to check before applying these operations in production.

1. 1Java Math.abs on Integer.MIN_VALUE: detect the one value that cannot turn positive
2. 2Java floorDiv and floorMod: assign negative coordinates to stable buckets
3. 3Java BigDecimal.divide: make nonterminating quotients explicit
4. 4Java RoundingMode.UNNECESSARY: reject hidden fractional cents
5. 5Java BigInteger.intValueExact: reject a narrowing conversion
6. 6Java Double NaN and signed zero: primitive and wrapper comparisons differ
7. 7Java Double.isFinite: reject Infinity and NaN at input boundaries
8. 8Java floating-point sums: input order can change the result
9. 9Java unsigned int parsing: preserve 32-bit protocol values
10. 10Java long to double: large integer IDs can lose unit precision

Failure cases and API contracts to check before applying these operations in production.

1. 1Java Pattern.quote: match a supplied token literally
2. 2Java Matcher.quoteReplacement: keep dollar signs and backslashes as data
3. 3Java Matcher.matches and find: whole-input validation versus extraction
4. 4Java Matcher.find: account for the scan cursor and zero-length matches
5. 5Java Matcher groups: distinguish absent optional captures from empty text
6. 6Java regex Unicode classes: decide what a word character means
7. 7Java String.split limit: retain trailing empty fields in records

Failure cases and API contracts to check before applying these operations in production.

1. 1Java synchronized LinkedList iteration: hold the wrapper lock for the whole scan
2. 2Java LinkedList remove overloads: index versus Integer value
3. 3Java List.replaceAll: a thrown operator can leave earlier elements changed
4. 4Java Collections.copy: the destination must already have slots
5. 5Java Collections.rotate on a subList: change only a live window
6. 6Java Collections.asLifoQueue: a Queue view with stack ordering
7. 7Java Collections.nCopies: repeated slots can share one mutable object
8. 8Java LinkedList spliterator: traversal binds after creation

Failure cases and API contracts to check before applying these operations in production.

1. 1Java SHA-256: hash declared bytes, not an implicit string encoding
2. 2Java MessageDigest.update(ByteBuffer): the input position moves to its limit
3. 3Java HmacSHA256 verification: reject a changed message
4. 4Java HMAC field framing: prevent ambiguous concatenation
5. 5Java SecureRandom token encoding: preserve unpredictable bytes in a URL-safe form
6. 6Java AES-GCM: reject a changed ciphertext before accepting plaintext
7. 7Java AES-GCM associated data: bind ciphertext to its record context
8. 8Java Base64 URL encoding: choose the alphabet at the transport boundary

Failure cases and API contracts to check before applying these operations in production.

1. 1Java streams are single-use: create a new pipeline for each pass
2. 2Java Stream.peek: observation is not a correctness hook
3. 3Java Collectors.toMap: choose a duplicate-key rule
4. 4Java Collectors.groupingBy: reject or normalize null classifier keys
5. 5Java Collectors.toMap: preserve encounter order with LinkedHashMap
6. 6Java parallel streams: forEach and forEachOrdered have different order contracts
7. 7Java Stream.reduce: identity and associative accumulator contracts
8. 8Java Stream.anyMatch: stop on a decision, not on every element