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