## org.apache.commons.collections.list
Class AbstractLinkedList

    java.lang.Object
      org.apache.commons.collections.list.AbstractLinkedList

All Implemented Interfaces:
  Collection, List

Direct Known Subclasses:
  CursorableLinkedList, NodeCachingLinkedList

public abstract class AbstractLinkedList
extends Object
implements List

An abstract implementation of a linked list which provides numerous points for subclasses to override.

Overridable methods are provided to change the storage node and to change how nodes are added to and removed. Hopefully, all you need for unusual subclasses is here.

Since:
  Commons Collections 3.0
Version:
  $Revision: 1.9 $ $Date: 2004/04/20 23:33:54 $
Author:
  Rich Dougherty, Phil Steitz, Stephen Colebourne

Nested Class Summary
`protected static class` `AbstractLinkedList.LinkedListIterator` A list iterator over the linked list.
`protected static class` `AbstractLinkedList.LinkedSubList` The sublist implementation for AbstractLinkedList.
`protected static class` `AbstractLinkedList.LinkedSubListIterator` A list iterator over the linked sub list.
`protected static class` `AbstractLinkedList.Node` A node within the linked list.

Field Summary
`protected AbstractLinkedList.Node` `header` A `AbstractLinkedList.Node` which indicates the start and end of the list and does not hold a value.
`protected int` `modCount` Modification count for iterators
`protected int` `size` The size of the list

Constructor Summary
`protected` `AbstractLinkedList()` Constructor that does nothing intended for deserialization.
`protected` `AbstractLinkedList(Collection coll)` Constructs a list copying data from the specified collection.

Method Summary
`void` `add(int index, Object value)`
`boolean` `add(Object value)`
`boolean` `addAll(Collection coll)`
`boolean` `addAll(int index, Collection coll)`
`boolean` `addFirst(Object o)`
`boolean` `addLast(Object o)`
`protected void` `addNode(AbstractLinkedList.Node nodeToInsert, AbstractLinkedList.Node insertBeforeNode)` Inserts a new node into the list.
`protected void` `addNodeAfter(AbstractLinkedList.Node node, Object value)` Creates a new node with the specified object as its `value` and inserts it after `node`.
`protected void` `addNodeBefore(AbstractLinkedList.Node node, Object value)` Creates a new node with the specified object as its `value` and inserts it before `node`.
`void` `clear()`
`boolean` `contains(Object value)`
`boolean` `containsAll(Collection coll)`
`protected AbstractLinkedList.Node` `createHeaderNode()` Creates a new node with previous, next and element all set to null.
`protected AbstractLinkedList.Node` `createNode(Object value)` Creates a new node with the specified properties.
`protected Iterator` `createSubListIterator(AbstractLinkedList.LinkedSubList subList)` Creates an iterator for the sublist.
`protected ListIterator` `createSubListListIterator(AbstractLinkedList.LinkedSubList subList, int fromIndex)` Creates a list iterator for the sublist.
`protected void` `doReadObject(ObjectInputStream inputStream)` Deserializes the data held in this object to the stream specified.
`protected void` `doWriteObject(ObjectOutputStream outputStream)` Serializes the data held in this object to the stream specified.
`boolean` `equals(Object obj)`
`Object` `get(int index)`
`Object` `getFirst()`
`Object` `getLast()`
`protected AbstractLinkedList.Node` `getNode(int index, boolean endMarkerAllowed)` Gets the node at a particular index.
`int` `hashCode()`
`int` `indexOf(Object value)`
`protected void` `init()` The equivalent of a default constructor, broken out so it can be called by any constructor and by `readObject`.
`boolean` `isEmpty()`
`protected boolean` `isEqualValue(Object value1, Object value2)` Compares two values for equals.
`Iterator` `iterator()`
`int` `lastIndexOf(Object value)`
`ListIterator` `listIterator()`
`ListIterator` `listIterator(int fromIndex)`
`Object` `remove(int index)`
`boolean` `remove(Object value)`
`boolean` `removeAll(Collection coll)`
`protected void` `removeAllNodes()` Removes all nodes by resetting the circular list marker.
`Object` `removeFirst()`
`Object` `removeLast()`
`protected void` `removeNode(AbstractLinkedList.Node node)` Removes the specified node from the list.
`boolean` `retainAll(Collection coll)`
`Object` `set(int index, Object value)`
`int` `size()`
`List` `subList(int fromIndexInclusive, int toIndexExclusive)` Gets a sublist of the main list.
`Object[]` `toArray()`
`Object[]` `toArray(Object[] array)`
`String` `toString()`
`protected void` `updateNode(AbstractLinkedList.Node node, Object value)` Updates the node with a new value.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### header

    protected transient AbstractLinkedList.Node header

  A `AbstractLinkedList.Node` which indicates the start and end of the list and does not hold a value. The value of `next` is the first item in the list. The value of of `previous` is the last item in the list.

### size

    protected transient int size

  The size of the list

### modCount

    protected transient int modCount

  Modification count for iterators

Constructor Detail

### AbstractLinkedList

    protected AbstractLinkedList()

  Constructor that does nothing intended for deserialization.

  If this constructor is used by a serializable subclass then the init() method must be called.

### AbstractLinkedList

    protected AbstractLinkedList(Collection coll)

  Constructs a list copying data from the specified collection.

Parameters:
  `coll` - the collection to copy

Method Detail

### init

    protected void init()

  The equivalent of a default constructor, broken out so it can be called by any constructor and by `readObject`. Subclasses which override this method should make sure they call super, so the list is initialised properly.

### size

    public int size()

  Specified by:
    `size` in interface `List`

### isEmpty

    public boolean isEmpty()

  Specified by:
    `isEmpty` in interface `List`

### get

    public Object get(int index)

  Specified by:
    `get` in interface `List`

### iterator

    public Iterator iterator()

  Specified by:
    `iterator` in interface `List`

### listIterator

    public ListIterator listIterator()

  Specified by:
    `listIterator` in interface `List`

### listIterator

    public ListIterator listIterator(int fromIndex)

  Specified by:
    `listIterator` in interface `List`

### indexOf

    public int indexOf(Object value)

  Specified by:
    `indexOf` in interface `List`

### lastIndexOf

    public int lastIndexOf(Object value)

  Specified by:
    `lastIndexOf` in interface `List`

### contains

    public boolean contains(Object value)

  Specified by:
    `contains` in interface `List`

### containsAll

    public boolean containsAll(Collection coll)

  Specified by:
    `containsAll` in interface `List`

### toArray

    public Object[] toArray()

  Specified by:
    `toArray` in interface `List`

### toArray

    public Object[] toArray(Object[] array)

  Specified by:
    `toArray` in interface `List`

### subList

    public List subList(int fromIndexInclusive,
                        int toIndexExclusive)

  Gets a sublist of the main list.

  Specified by:
    `subList` in interface `List`
  Parameters:
    `fromIndexInclusive` - the index to start from
    `toIndexExclusive` - the index to end at
  Returns:
    the new sublist

### add

    public boolean add(Object value)

  Specified by:
    `add` in interface `List`

### add

    public void add(int index,
                    Object value)

  Specified by:
    `add` in interface `List`

### addAll

    public boolean addAll(Collection coll)

  Specified by:
    `addAll` in interface `List`

### addAll

    public boolean addAll(int index,
                          Collection coll)

  Specified by:
    `addAll` in interface `List`

### remove

    public Object remove(int index)

  Specified by:
    `remove` in interface `List`

### remove

    public boolean remove(Object value)

  Specified by:
    `remove` in interface `List`

### removeAll

    public boolean removeAll(Collection coll)

  Specified by:
    `removeAll` in interface `List`

### retainAll

    public boolean retainAll(Collection coll)

  Specified by:
    `retainAll` in interface `List`

### set

    public Object set(int index,
                      Object value)

  Specified by:
    `set` in interface `List`

### clear

    public void clear()

  Specified by:
    `clear` in interface `List`

### getFirst

    public Object getFirst()

### getLast

    public Object getLast()

### addFirst

    public boolean addFirst(Object o)

### addLast

    public boolean addLast(Object o)

### removeFirst

    public Object removeFirst()

### removeLast

    public Object removeLast()

### equals

    public boolean equals(Object obj)

  Specified by:
    `equals` in interface `List`

### hashCode

    public int hashCode()

  Specified by:
    `hashCode` in interface `List`

### toString

    public String toString()

### isEqualValue

    protected boolean isEqualValue(Object value1,
                                   Object value2)

  Compares two values for equals. This implementation uses the equals method. Subclasses can override this to match differently.

  Parameters:
    `value1` - the first value to compare, may be null
    `value2` - the second value to compare, may be null
  Returns:
    true if equal

### updateNode

    protected void updateNode(AbstractLinkedList.Node node,
                              Object value)

  Updates the node with a new value. This implementation sets the value on the node. Subclasses can override this to record the change.

  Parameters:
    `node` - node to update
    `value` - new value of the node

### createHeaderNode

    protected AbstractLinkedList.Node createHeaderNode()

  Creates a new node with previous, next and element all set to null. This implementation creates a new empty Node. Subclasses can override this to create a different class.

  Returns:
    newly created node

### createNode

    protected AbstractLinkedList.Node createNode(Object value)

  Creates a new node with the specified properties. This implementation creates a new Node with data. Subclasses can override this to create a different class.

  Parameters:
    `value` - value of the new node

### addNodeBefore

    protected void addNodeBefore(AbstractLinkedList.Node node,
                                 Object value)

  Creates a new node with the specified object as its `value` and inserts it before `node`.

  This implementation uses `createNode(Object)` and `addNode(AbstractLinkedList.Node,AbstractLinkedList.Node)`.

  Parameters:
    `node` - node to insert before
    `value` - value of the newly added node
  Throws:
    `NullPointerException` - if `node` is null

### addNodeAfter

    protected void addNodeAfter(AbstractLinkedList.Node node,
                                Object value)

  Creates a new node with the specified object as its `value` and inserts it after `node`.

  This implementation uses `createNode(Object)` and `addNode(AbstractLinkedList.Node,AbstractLinkedList.Node)`.

  Parameters:
    `node` - node to insert after
    `value` - value of the newly added node
  Throws:
    `NullPointerException` - if `node` is null

### addNode

    protected void addNode(AbstractLinkedList.Node nodeToInsert,
                           AbstractLinkedList.Node insertBeforeNode)

  Inserts a new node into the list.

  Parameters:
    `nodeToInsert` - new node to insert
    `insertBeforeNode` - node to insert before
  Throws:
    `NullPointerException` - if either node is null

### removeNode

    protected void removeNode(AbstractLinkedList.Node node)

  Removes the specified node from the list.

  Parameters:
    `node` - the node to remove
  Throws:
    `NullPointerException` - if `node` is null

### removeAllNodes

    protected void removeAllNodes()

  Removes all nodes by resetting the circular list marker.

### getNode

    protected AbstractLinkedList.Node getNode(int index,
                                              boolean endMarkerAllowed)
                                       throws IndexOutOfBoundsException

  Gets the node at a particular index.

  Parameters:
    `index` - the index, starting from 0
    `endMarkerAllowed` - whether or not the end marker can be returned if startIndex is set to the list's size
  Throws:
    `IndexOutOfBoundsException` - if the index is less than 0; equal to the size of the list and endMakerAllowed is false; or greater than the size of the list

### createSubListIterator

    protected Iterator createSubListIterator(AbstractLinkedList.LinkedSubList subList)

  Creates an iterator for the sublist.

  Parameters:
    `subList` - the sublist to get an iterator for

### createSubListListIterator

    protected ListIterator createSubListListIterator(AbstractLinkedList.LinkedSubList subList,
                                                     int fromIndex)

  Creates a list iterator for the sublist.

  Parameters:
    `subList` - the sublist to get an iterator for
    `fromIndex` - the index to start from, relative to the sublist

### doWriteObject

    protected void doWriteObject(ObjectOutputStream outputStream)
                          throws IOException

  Serializes the data held in this object to the stream specified.

  The first serializable subclass must call this method from `writeObject`.

  Throws:
    `IOException`

### doReadObject

    protected void doReadObject(ObjectInputStream inputStream)
                         throws IOException,
                                ClassNotFoundException

  Deserializes the data held in this object to the stream specified.

  The first serializable subclass must call this method from `readObject`.

  Throws:
    `IOException`
    `ClassNotFoundException`

Copyright © 2001-2005 Apache Software Foundation. All Rights Reserved.