Java List implementation that lazily initializes its contents when any method is called.

LazyList.java

import org.apache.commons.lang3.concurrent.ConcurrentException;
import org.apache.commons.lang3.concurrent.LazyInitializer;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public abstract class LazyList<E> implements List<E> {
	private LazyInitializer<List<E>> initializer = new LazyInitializer<List<E>>() {

		@Override
		protected List<E> initialize() throws ConcurrentException {
			return LazyList.this.initialize();
		}
	};

	protected abstract List<E> initialize();

	@Override
	public int size() {
		return delegate().size();
	}

	private List<E> delegate() {
		try {
			return initializer.get();
		} catch (ConcurrentException e) {
            throw new RuntimeException(e);
		}
	}

	@Override
	public boolean isEmpty() {
		return delegate().isEmpty();
	}

	@Override
	public boolean contains(Object o) {
		return delegate().contains(o);
	}

	@Override
	public Iterator<E> iterator() {
		return delegate().iterator();
	}

	@Override
	public Object[] toArray() {
		return delegate().toArray();
	}

	@Override
	public <T> T[] toArray(T[] a) {
		return delegate().toArray(a);
	}

	@Override
	public boolean add(E e) {
		return delegate().add(e);
	}

	@Override
	public boolean remove(Object o) {
		return delegate().remove(o);
	}

	@Override
	public boolean containsAll(Collection<?> c) {
		return delegate().containsAll(c);
	}

	@Override
	public boolean addAll(Collection<? extends E> c) {
		return delegate().addAll(c);
	}

	@Override
	public boolean addAll(int index, Collection<? extends E> c) {
		return delegate().addAll(index, c);
	}

	@Override
	public boolean removeAll(Collection<?> c) {
		return delegate().removeAll(c);
	}

	@Override
	public boolean retainAll(Collection<?> c) {
		return delegate().retainAll(c);
	}

	@Override
	public void clear() {
		delegate().clear();
	}

	@Override
	public E get(int index) {
		return delegate().get(index);
	}

	@Override
	public E set(int index, E element) {
		return delegate().set(index, element);
	}

	@Override
	public void add(int index, E element) {
		delegate().add(index, element);
	}

	@Override
	public E remove(int index) {
		return delegate().remove(index);
	}

	@Override
	public int indexOf(Object o) {
		return delegate().indexOf(o);
	}

	@Override
	public int lastIndexOf(Object o) {
		return delegate().lastIndexOf(o);
	}

	@Override
	public ListIterator<E> listIterator() {
		return delegate().listIterator();
	}

	@Override
	public ListIterator<E> listIterator(int index) {
		return delegate().listIterator(index);
	}

	@Override
	public List<E> subList(int fromIndex, int toIndex) {
		return delegate().subList(fromIndex, toIndex);
	}
}