Top Description Classes

[default module]

Package org.apache.commons.collections4.list

This package contains implementations of the List interface.

The following implementations are provided in the package:

TreeList - a list that is optimised for insertions and removals at any index in the list
CursorableLinkedList - a list that can be modified while the listIterator (cursor) is being used
NodeCachingLinkedList - a linked list that caches the storage nodes for a performance gain

The following decorators are provided in the package:

Unmodifiable - ensures the collection cannot be altered
Predicated - ensures that only elements that are valid according to a predicate can be added
Transformed - transforms each element added
FixedSize - ensures that the size of the list cannot change
Lazy - creates objects in the list on demand
Growth - grows the list instead of erroring when set/add used with index beyond the list size
SetUnique - a list that avoids duplicate entries like a Set

Class Summary

Modifier and Type	Class and Description
public abstract class	AbstractLinkedList<E> An abstract implementation of a linked list which provides numerous points for subclasses to override.
public abstract class	AbstractListDecorator< the type of the elements in the list E> Decorates another `List` to provide additional behaviour.
public abstract class	AbstractSerializableListDecorator<E> Serializable subclass of AbstractListDecorator.
public class	CursorableLinkedList<E> A `List` implementation with a `ListIterator` that allows concurrent modifications to the underlying list.
public class	FixedSizeList< the type of elements in this collection E> Decorates another `List` to fix the size preventing add/remove.
public class	GrowthList<E> Decorates another `List` to make it seamlessly grow when indices larger than the list size are used on add and set, avoiding most IndexOutOfBoundsExceptions.
public class	LazyList<E> Decorates another `List` to create objects in the list on demand.
public class	NodeCachingLinkedList<E> A `List` implementation that stores a cache of internal Node objects in an effort to reduce wasteful object creation.
public class	PredicatedList<E> Decorates another `List` to validate that all additions match a specified predicate.
public class	SetUniqueList<E> Decorates a `List` to ensure that no duplicates are present much like a `Set`.
public class	TransformedList<E> Decorates another `List` to transform objects that are added.
public class	TreeList<E> A `List` implementation that is optimised for fast insertions and removals at any index in the list.
public class	UnmodifiableList<E> Decorates another `List` to ensure it can't be altered.