Course contentsShow
← Java
Lesson 1042 of 2,87024. List ImplementationsFree lesson

Memory Overhead: ArrayList Capacity vs LinkedList Nodes

ArrayList uses contiguous array with unused capacity; LinkedList stores prev/next pointers per node.

Memory Overhead: ArrayList Capacity vs LinkedList Nodes

What you'll learn: How ArrayList and LinkedList differ in memory consumption due to their internal storage mechanisms.

The Memory Trade-Off

Both ArrayList and LinkedList store the same logical data, but they consume different amounts of memory because of how they're structured internally.

ArrayList: Array + Unused Capacity

An ArrayList uses a contiguous array as its backing store. Because it grows dynamically, it typically allocates more capacity than currently needed to avoid frequent resizing.

For example, if you add 10 elements:

  • The ArrayList might have size = 10 but capacity = 15
  • That means 5 unused array slots are sitting idle in memory
  • Memory used: references for 15 elements (even though only 10 are populated)

Think of it like renting a storage unit: you pay for the entire space, even if you only fill half of it.

LinkedList: Node Objects with Pointers

A LinkedList stores each element in a separate node object that contains:

  • The element reference
  • A reference to the previous node
  • A reference to the next node

For 10 elements:

  • Memory used: 10 node objects (no wasted capacity)
  • Each node has 3 references (element, prev, next) plus object header overhead

Think of it like a chain: every link carries extra metal (the connection points) even though you only care about what's dangling from it.

The Comparison

  • ArrayList: Wastes space in unused capacity (~33-50% overhead after growth), but each element is just one reference
  • LinkedList: No wasted capacity, but each element requires a full node object with two extra pointers

For small objects, LinkedList's per-element overhead (node object + 2 pointers) typically exceeds ArrayList's unused capacity overhead.

Key Takeaway: ArrayList wastes space through unused array capacity; LinkedList wastes space through per-node pointer overhead—for most cases, ArrayList is more memory-efficient despite its spare capacity.