How Java works

Pick a topic, write code and watch what happens inside, step by step.

Memory

JVM: Stack and Heap

Primitives, objects, the String Pool, frames and GC. Follow line by line where your code lands in memory.

Garbage Collection

When is an object removed? GC roots, mark-sweep, Eden, Survivor, Old and memory leaks.

String inside

What is inside a String: byte[], LATIN1 and UTF16, emoji length, shared arrays and the cost of +=.

Objects in memory

How many bytes an object takes: header, mark word, padding, field order, arrays and the 32 GB line.

Collections

How HashMap works

hashCode, buckets, collisions and resize. Follow bit by bit how a key finds its place in the table.

How TreeMap works

Watch a red-black tree live: insert, recolor, rotation, remove and ordered search.

Concurrency

Threads

Drive two threads yourself. Race conditions, synchronized, volatile, CAS and deadlock.

How ConcurrentHashMap works

A HashMap for several threads. CAS on an empty bucket, a lock on a full one, resize and no nulls.

Virtual threads

How a million threads become possible: carriers, mount and unmount, pinning and where virtual threads do not help.

Language and JVM

Bytecode

What does javac write? The operand stack, local variables, the i = i++ trap and what finally really is.

Class loading

When is a class loaded? Delegation, three stages, static and constructor order, classic traps.

How Stream works

Streams are lazy. Elements pass one by one, sorted holds them all, and count sometimes runs nothing.

Topics

Class loading

ClassLoaders and delegation

Three main ClassLoaders load classes. Each one asks its parent first, and searches itself only if the parent finds nothing.

This is why your own java.lang.String would not replace the one from the JDK.

Pick a class with the buttons and follow the request.

Three stages

A class is loaded, then linked, then initialized. Each happens once.

In Preparation, static fields get default values. The value you wrote arrives only in Initialization.

The JVM does not initialize a class until its first real use.

Static and constructor order

A favorite interview question: the static part first, parent to child. Then for each new, the instance part, again parent to child.

Inside a class, fields and blocks run in written order. The constructor body is last.

Follow how the output appears line by line.

A virtual method in a constructor

name is written as "Aysel", yet the first output is name=null.

The parent constructor calls a virtual method and Java picks the child version. At that moment the fields of the child are not set.

The rule: do not call overridable methods in a constructor.

When does initialization happen?

It takes real use: new, a static method, or a static field that is not a constant.

static final int X = 5 is a compile-time constant, copied at compile time. static final Integer Y is not a constant.

Using a parent field through the child name initializes only the parent. Creating an array initializes nothing.

Two traps

Static fields run in line order. When a reads c, c is still 0, not 10.

An exception in <clinit> breaks the class for good: ExceptionInInitializerError the first time, then NoClassDefFoundError every time.

The second error hides the real cause, so look for the first one in the log.