Package org.apache.commons.collections4.list

Class AbstractLinkedList<E>

  • All Implemented Interfaces:
    Iterable<E>, Collection<E>, List<E>
    Direct Known Subclasses:
    CursorableLinkedList, NodeCachingLinkedList
    public abstract class AbstractLinkedList<E>
extends Object
implements List<E>
    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:
    3.0

    • Field Detail

      • header

        transient AbstractLinkedList.Node<E> 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

        transient int size
        The size of the list

      • modCount

        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<? extends E> 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.

      • get

        public E get​(int index)
        Specified by:
        get in interface List<E>

      • indexOf

        public int indexOf​(Object value)
        Specified by:
        indexOf in interface List<E>

      • subList

        public List<E> subList​(int fromIndexInclusive,
                       int toIndexExclusive)
        Gets a sublist of the main list.
        Specified by:
        subList in interface List<E>
        Parameters:
        fromIndexInclusive - the index to start from
        toIndexExclusive - the index to end at
        Returns:
        the new sublist

      • add

        public boolean add​(E value)
        Specified by:
        add in interface Collection<E>
        Specified by:
        add in interface List<E>

      • add

        public void add​(int index,
                E value)
        Specified by:
        add in interface List<E>

      • addAll

        public boolean addAll​(int index,
                      Collection<? extends E> coll)
        Specified by:
        addAll in interface List<E>

      • remove

        public E remove​(int index)
        Specified by:
        remove in interface List<E>

      • removeAll

        public boolean removeAll​(Collection<?> coll)

        This implementation iterates over the elements of this list, checking each element in turn to see if it's contained in coll. If it's contained, it's removed from this list. As a consequence, it is advised to use a collection type for coll that provides a fast (e.g. O(1)) implementation of Collection.contains(Object).

        Specified by:
        removeAll in interface Collection<E>
        Specified by:
        removeAll in interface List<E>

      • retainAll

        public boolean retainAll​(Collection<?> coll)

        This implementation iterates over the elements of this list, checking each element in turn to see if it's contained in coll. If it's not contained, it's removed from this list. As a consequence, it is advised to use a collection type for coll that provides a fast (e.g. O(1)) implementation of Collection.contains(Object).

        Specified by:
        retainAll in interface Collection<E>
        Specified by:
        retainAll in interface List<E>

      • set

        public E set​(int index,
             E value)
        Specified by:
        set in interface List<E>

      • getFirst

        public E getFirst()

      • getLast

        public E getLast()

      • addFirst

        public boolean addFirst​(E o)

      • addLast

        public boolean addLast​(E o)

      • removeFirst

        public E removeFirst()

      • removeLast

        public E removeLast()

      • 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<E> node,
                          E 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<E> 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<E> createNode​(E 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
        Returns:
        a new node containing the value

      • removeAllNodes

        protected void removeAllNodes()
        Removes all nodes by resetting the circular list marker.

      • getNode

        protected AbstractLinkedList.Node<E> 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
        Returns:
        the node at the given index
        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<E> createSubListIterator​(AbstractLinkedList.LinkedSubList<E> subList)
        Creates an iterator for the sublist.
        Parameters:
        subList - the sublist to get an iterator for
        Returns:
        a new iterator on the given sublist

      • createSubListListIterator

        protected ListIterator<E> createSubListListIterator​(AbstractLinkedList.LinkedSubList<E> 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
        Returns:
        a new list iterator on the given 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.

        Parameters:
        outputStream - the stream to write the object to
        Throws:
        IOException - if anything goes wrong

      • 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.

        Parameters:
        inputStream - the stream to read the object from
        Throws:
        IOException - if any error occurs while reading from the stream
        ClassNotFoundException - if a class read from the stream can not be loaded