Articles tagged with #Data Structures
A curated list of engineering series, deep dives, and notes related to #Data Structures.
Building a Custom In-Memory Data Store in Java: The Collections Capstone
Build a production-grade in-memory key-value database in Java from scratch using custom data structures: HashMaps, LRU caches, priority queues, and SkipLists.
Java Specialized Queues: SynchronousQueue Handoffs & DelayQueue Expiration
Master Java SynchronousQueue and DelayQueue internals. Learn zero-capacity thread handoffs and how Delayed Min-Heaps power task schedulers.
Lock-Free Sorted Range Queries: ConcurrentSkipListMap & SkipLists in Java
Learn how ConcurrentSkipListMap uses SkipLists and atomic CAS pointers to deliver lock-free sorted range queries across 64+ CPU cores in Java.
Java BlockingQueue Performance: ArrayBlockingQueue vs LinkedBlockingQueue
Compare ArrayBlockingQueue vs LinkedBlockingQueue in Java. Learn how dual-lock splitting eliminates contention in multi-threaded task queues.
Java IdentityHashMap Internals: Reference Equality & Open Addressing Probing
Learn how Java IdentityHashMap uses reference equality (==) and flat array linear probing to prevent infinite recursion in object graph serializers.
Java WeakHashMap Internals: Preventing Memory Leaks with Weak References
Explore how Java WeakHashMap uses WeakReference keys and ReferenceQueue polling to prevent memory leaks in caches and plugin frameworks.
High-Performance Java: How EnumSet and EnumMap Achieve Zero-Allocation Speed
Discover why EnumSet and EnumMap are the fastest collections in Java. Learn how 64-bit long bitmasks execute set operations in 1 CPU cycle.
Java ConcurrentHashMap Internals: Lock-Free CAS & Fine-Grained Bucket Sync
Deep dive into Java 8+ ConcurrentHashMap internals. Learn how lock-free CAS, volatile reads, and bucket-level synchronized locks handle high concurrency.
Java Concurrent Collections: CopyOnWriteArrayList vs Unmodifiable vs List.of()
Compare Fail-Fast vs Fail-Safe collections in Java. Learn CopyOnWriteArrayList memory mechanics and the difference between List.of() and unmodifiable wrappers.
Java PriorityQueue Internals: Building a Min-Heap Array from Scratch
Build a custom PriorityQueue in Java using a flat Min-Heap array. Learn parent-child index formulas, siftUp, and siftDown algorithms.
Java TreeMap Internals: Building a Navigable Sorted Map from Scratch
Build a custom TreeMap in Java. Learn how NavigableMap range queries and custom Comparators maintain sorted keys in O(log N) time.
Red-Black Tree Rotations Explained: Self-Balancing Trees in Java
Demystify Red-Black tree rotations and recoloring. Understand how Java TreeMap and HashMap maintain O(log N) balance guarantees.
Building a Binary Search Tree (BST) in Java: Recursive Operations & Range Queries
Implement a Binary Search Tree in Java. Learn recursive insertion, in-order traversal for sorted data, and why skewed trees degrade.
Building a Custom LRU Cache in Java Using LinkedHashMap
Build an LRU Cache in Java in 10 lines of code by extending LinkedHashMap and leveraging access-order doubly linked entry pointers.
How Java HashSet Works Under the Hood: Building a Set via Composition
Discover how Java HashSet uses composition to wrap HashMap key uniqueness, spending zero extra memory on static dummy value references.
Java HashMap Internals (Part 2): Load Factor, Resizing & Red-Black Treeification
Learn how Java HashMap resizes its bucket table when reaching load factor threshold, and how JDK 8 treeifies long bucket chains.
Java HashMap Internals (Part 1): Hashing Functions, Buckets & Separate Chaining
Deep dive into Java HashMap internals. Learn how hash functions, bitwise masking, and separate bucket chaining store key-value pairs.
Building a Double-Ended Queue (Deque) in Java for Sliding Window Algorithms
Implement a custom ArrayDeque in Java for dual-ended operations. Solve sliding window maximum algorithms in O(1) time.
Building a Circular Queue in Java: Array Ring Buffers and Modulo Math
Build a high-performance circular array queue in Java. Eliminate O(N) array shifts using modulo arithmetic head and tail pointers.
Building a Custom Java Stack: LIFO Mechanics & Why Legacy Stack is Broken
Build a custom LIFO Stack in Java. Learn why java.util.Stack is obsolete and how ArrayDeque provides better performance.
Java Iterator and modCount: How Fail-Fast Iteration Prevents Data Corruption
Explore how Java iterators use modCount to throw ConcurrentModificationException and prevent silent data corruption during list traversal.
Java LinkedList Internals: Building a Doubly Linked List from Scratch
Learn how Java LinkedList works under the hood by building a doubly linked list. Compare ArrayList vs LinkedList performance trade-offs.
How Java ArrayList Works Internally: Building a Dynamic Array from Scratch
Build a custom ArrayList in Java from scratch. Understand dynamic array resizing, System.arraycopy performance, and garbage collection.
The Append-Only Log Abstraction: Why Immutability Rules Event Streaming
Explore the append-only log data structure behind Apache Kafka. Learn how immutability enables lock-free concurrency and multi-team data replay.
Java equals() and hashCode() Contract: Avoiding Silent HashMap Bugs
Learn the unbreakable contract between equals() and hashCode() in Java to prevent silent HashMap lookup bugs and memory leaks.
Java Memory Model Explained: Stack vs Heap Allocation for Arrays
Understand how the JVM allocates memory on the stack and heap when declaring primitive and object reference arrays in Java.
Mastering Java Collections from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 25-part series on Java Collections internals. Build data structures from scratch and master memory mechanics.