skip to content

How does AbstractList use Template Method, and what does a minimal immutable List subclass look like?

level: middleimportance: should knowfreq 55%

answer

  1. AbstractList primitives: get(int) + size()
  2. Skeletal implementation idiom (Effective Java)
  3. Override set/add/remove for mutability
  4. Default add/set/remove throw UnsupportedOperationException
  5. modCount drives fail-fast iterators

basics

~20 s

AbstractList already writes most of the List methods (iterator, indexOf, equals, etc.) using two abstract steps you provide: get(index) and size(). To make a read-only list you extend AbstractList and implement just those two methods.

solid answer

~40 s

AbstractList is a 'skeletal implementation' of the List interface. It implements the bulk of the contract — iterator(), listIterator(), indexOf(), lastIndexOf(), equals(), hashCode(), subList() — entirely in terms of two abstract primitive methods: get(int) and size(). That is Template Method at collection scale: the algorithms (iteration order, equality semantics) are the skeleton, and get/size are the gaps. To create a minimal immutable list you extend AbstractList<E>, implement get and size, and inherit everything else correctly. If you also override set, add, and remove you get a mutable list. This is Effective Java's 'skeletal implementation' idiom: the interface (List) declares the type, the abstract class (AbstractList) supplies the heavy lifting, and your class supplies only the data-backed primitives.

code

java · 20 lines
java
import java.util.AbstractList;

final class IntRangeList extends AbstractList<Integer> {
    private final int start, count;
    IntRangeList(int start, int count) { this.start = start; this.count = count; }

    @Override public Integer get(int index) {            // primitive method
        if (index < 0 || index >= count)
            throw new IndexOutOfBoundsException("" + index);
        return start + index;
    }
    @Override public int size() { return count; }         // primitive method
}

// Inherited (skeleton) behavior, all from get + size:
//   var r = new IntRangeList(10, 3);
//   r.contains(11)         -> true
//   r.indexOf(12)          -> 2
//   r.equals(List.of(10,11,12)) -> true
//   for (int x : r) ...    -> 10, 11, 12

go deeper

for a junior

Knows that extending AbstractList and implementing get and size yields a working read-only list.

for a middle

Can write the minimal subclass, explains that the inherited methods are built on get/size, and that mutators must be overridden for a mutable list.

for a senior

Connects it to the 'skeletal implementation' idiom, explains the read-only-by-default mutators, fail-fast modCount, and the equals/hashCode contract reuse.

for a principal

Evaluates trade-offs of the abstract-class skeleton vs. interface default methods, performance of get-based iteration for non-random-access stores, and when AbstractSequentialList is the better base.

## Background: interface vs. skeletal class In Java, `List<E>` is an **interface** — it declares ~25 methods but (historically) implements none. Implementing all of them by hand for every new list type would be enormous and error-prone. The JDK solves this with **skeletal implementation classes**: `AbstractList`, `AbstractSet`, `AbstractMap`, `AbstractCollection`, `AbstractQueue`. Each pairs with an interface and implements most of it, leaving a tiny set of **abstract primitive methods** for you. ## AbstractList's primitives `AbstractList<E>` declares exactly two abstract methods that a read-only list must supply: - `public abstract E get(int index);` - `public abstract int size();` Everything else is written **once** in terms of these. For example, `AbstractList`'s `iterator()` returns an inner `Itr` whose `next()` calls `get(cursor++)` and whose bounds come from `size()`. `indexOf(Object o)` loops `0..size()` calling `get(i)` and comparing. `equals()` walks two lists element-by-element via their iterators. Because these algorithms only ever touch the world through `get` and `size`, your subclass automatically gets a *correct, contract-compliant* implementation of all of them. This is the **Template Method** pattern: the algorithm skeletons (how to iterate, how to compute equality and hash code, how to search) live in the base class; the variable steps (where the data actually comes from) are the abstract primitives. ## A minimal immutable list ```java import java.util.AbstractList; final class IntRangeList extends AbstractList<Integer> { private final int start, count; IntRangeList(int start, int count) { this.start = start; this.count = count; } @Override public Integer get(int index) { // primitive if (index < 0 || index >= count) throw new IndexOutOfBoundsException("" + index); return start + index; } @Override public int size() { return count; } // primitive } // new IntRangeList(10, 3) behaves as [10, 11, 12]: // .contains(11) -> true, .indexOf(12) -> 2, iteration works, equals to List.of(10,11,12). ``` With only two methods you have a fully functional read-only `List` — `for (int x : list)`, `list.contains(11)`, `list.equals(other)`, and `list.stream()` all work, because each is built on `get`/`size`. ## Making it mutable If you also override: - `set(int index, E element)` → the list becomes *settable* (fixed-size mutable). - `add(int index, E element)` and `remove(int index)` → the list becomes *variable-size*. `AbstractList`'s default versions of these throw `UnsupportedOperationException`, which is exactly why an un-overridden `AbstractList` is read-only. ## The 'modCount' hook `AbstractList` also maintains a protected `modCount` field. Its iterators read it to implement **fail-fast** behavior — if the list is structurally modified during iteration (so `modCount` changes), the iterator throws `ConcurrentModificationException`. Subclasses that support modification are expected to bump `modCount`. This is part of the skeleton you inherit. ## Why this is good design - **Reuse:** dozens of methods written once, shared by every subclass and by the JDK's own `ArrayList`, `Vector`, and the lists returned by `Arrays.asList` and `List.of`. - **Correctness:** equality/hashCode/iteration semantics are guaranteed consistent across all lists. - **Minimal surface for the implementer:** you reason about *data access* (get/size), not algorithm plumbing. This is precisely the *skeletal implementation* recommendation in *Effective Java* (Item 20): provide an interface for the type and an abstract skeletal class for the work, so implementers write the fewest possible methods.

  • What happens if you call add() on an AbstractList subclass that only overrode get and size?
    AbstractList's default add throws UnsupportedOperationException, so the list is effectively read-only until you override the mutator methods.
  • Why does AbstractList provide equals() and hashCode() rather than leaving them to subclasses?
    The List interface specifies exact equals/hashCode semantics (order-sensitive element comparison). Implementing them once in the skeleton guarantees every list obeys the contract and that lists from different classes compare equal correctly.

  • Thinking you must implement iterator()/indexOf()/equals() yourself — AbstractList already does, via get/size.
  • Assuming an AbstractList subclass is mutable by default; the mutators throw UnsupportedOperationException until overridden.
  • Forgetting that get must throw IndexOutOfBoundsException for invalid indices, which the inherited algorithms rely on.

context