// Java, from first principles

Core Java, rebuilt by hand.

Data structures, concurrency primitives, and a DI container — built from scratch and test-driven, to prove how the abstractions actually work underneath.

Built by Aidar Kazybekov · GitHub · LinkedIn

Explore visualizations → View on GitHub ↗

11 components 104 tests green Java 21 zero runtime deps v1.0.0

MyHashMap.java

public void put(K key, V value) {
  int i = index(key);
  Node<K,V> cur = table[i];
  if (cur == null) {                // empty bucket
    table[i] = new Node<>(key, value);
    size++; resize();
    return;
  }
  while (true) {                  // walk the chain
    if (keysEqual(cur.key, key)) {
      cur.value = value; return;
    }
    if (cur.next == null) {
      cur.next = new Node<>(key, value); break;
    }
    cur = cur.next;
  }
  size++; resize();
}

Overview

What this is

Not a library to use — a proof of understanding. The set builds on itself: the LRU cache reuses the hand-written HashMap and linked list, the thread pool runs on the blocking queue, and the DI container caches its singletons in the HashMap.

Data structures

MyHashMap — chaining, resize, bit-spread index
MyArrayList — amortized-O(1) dynamic array
MyLinkedList — doubly linked
MyStack · MyQueue (ring buffer)
MyPriorityQueue — binary heap
MyLRUCache — O(1) get/put + eviction

Concurrency

thread-safe counter — synchronized vs CAS
producer–consumer — blocking queue, wait/notify
thread pool — workers + task queue

Framework

mini DI container — reflection, IoC, singletons

Explore

Two ways in

▶

Play

5 interactive visualizations — ring buffer, heap, LRU, race condition, thread pool. Step through them in the browser.

Open visualizations →

</>

Learn

10 concept deep-dives — how each piece works internally, with the interview angle for each.

Read concepts →