Language and framework depth for JVM roles, covering the internals that separate framework users from engineers who understand what runs underneath.
15 published across 10 topics.
Java fundamentals75 short answers on one page, for revising rather than studying.Object semantics, equals and hashCode contracts, generics, exceptions, and immutability.
Generic type arguments exist only for the compiler; the bytecode keeps a raw type plus a signature string, which is why there is no T.class and no new T[]. Wildcards then follow producer-extends, consumer-super: read through ? extends, write through ? super.
Equal objects must produce equal hash codes. Break that and a HashMap sends lookups to a bucket the entry was never placed in, so the map holds a value you can no longer retrieve and a set silently admits duplicates. The same failure appears later if a key is mutated after insertion.
Implementation internals, resizing behaviour, ordering guarantees, and choosing the right collection.
HashMap stores entries in an array of buckets indexed by a hash of the key; collisions chain into a linked list that converts to a red-black tree past a threshold, and exceeding the load factor triggers a resize that reallocates and redistributes every entry.
Structural modification through the collection during a for-each invalidates the iterator, which detects it by comparing a modification counter and throws ConcurrentModificationException. Remove through the iterator, or use removeIf, or pick a collection whose iterator is weakly consistent instead.
The memory model, executors, locks, atomics, virtual threads, and diagnosing races and deadlocks.
Virtual threads make blocking cheap by unmounting from their carrier OS thread whenever they block, so thread-per-request scales to hundreds of thousands of concurrent tasks. Finalised in JDK 21, they do nothing for CPU-bound work, and pooling them defeats their purpose.
It guarantees visibility and ordering: a volatile write happens-before every later read of that field, so everything the writer did beforehand becomes visible to the reader. It guarantees nothing about atomicity, so an increment is still a race and a volatile reference says nothing about the object it points to.
Class loading, memory regions, garbage collectors, and reading a heap dump or GC log.
Loaders delegate to their parent before searching themselves, so the JDK always wins a name clash. ClassNotFoundException means a loader was asked for bytes it could not find; NoClassDefFoundError means the JVM needed a class that was there at compile time, or one whose static initialiser had already failed.
Read the message text first, because it names which region ran out. Then use the GC log to see whether the live set after each full collection is trending upward, which means a leak, or flat and close to the ceiling, which means the heap is simply too small. A heap dump tells you what is retaining the memory.
Lazy evaluation, collectors, parallel streams, and the readability and performance traps.
Laziness means intermediate operations only describe a pipeline, so nothing traverses the source until a terminal operation pulls, and short-circuiting operations can stop early. Parallel helps when the source splits evenly, the work per element is CPU-bound and substantial.
Records, sealed types, pattern matching, and the language changes that reshape idiomatic code.
Together they let you write closed data hierarchies the compiler can check. A record declares that a type is its components, a sealed interface enumerates the permitted variants, and an exhaustive switch over record patterns turns adding a variant into a compile error at every place that handles them.
Dependency injection, bean lifecycle, scopes, proxies, and why an AOP annotation silently does nothing.
Spring applies @Transactional through a proxy that wraps the bean. Calling the annotated method from another method of the same class goes through `this`, not the proxy, so the advice never runs and no transaction is started. The same silence affects @Cacheable, @Async and @Retryable.
Auto-configuration mechanics, configuration precedence, actuator, and production-readiness concerns.
Boot loads a list of auto-configuration classes declared in each jar's AutoConfiguration.imports file, then applies each one only if its conditions hold. Because auto-configurations are evaluated after your own beans are registered, defining a bean yourself makes @ConditionalOnMissingBean back off.
Entity lifecycle, lazy loading and N+1, transaction propagation, and generated-SQL debugging.
A loaded entity is managed by the persistence context, which kept a snapshot of it. At flush the provider compares the entity against that snapshot and writes an UPDATE for whatever differs, so mutating a managed object inside a transaction is itself the instruction to persist.
You get N+1 when one query loads N rows and something later dereferences a lazy association on each of them, firing a select apiece. Fix it per call site with join fetch, an entity graph, or batch fetching - not by changing mappings to EAGER.
Unit versus integration boundaries, mocking strategy, Testcontainers, and suite design.
Draw the line by what the test is allowed to touch - a unit test stays in-process, an integration test crosses a real boundary. Mock collaborators, never the component under test. Use Testcontainers for real dependencies and keep the suite fast by reusing the Spring context and the containers.