org.apache.commons.collections4.list

## Class CursorableLinkedList.Cursor<E>

- java.lang.Object
- - org.apache.commons.collections4.list.AbstractLinkedList.LinkedListIterator<E>
  - - org.apache.commons.collections4.list.CursorableLinkedList.Cursor<E>

- All Implemented Interfaces:
    Iterator<E>, ListIterator<E>, OrderedIterator<E>
  Direct Known Subclasses:
    CursorableLinkedList.SubCursor
  Enclosing class:
    CursorableLinkedList<E>

      public static class CursorableLinkedList.Cursor<E>
      extends AbstractLinkedList.LinkedListIterator<E>

  An extended `ListIterator` that allows concurrent changes to the underlying list.

- - ### Field Summary

    - ### Fields inherited from class org.apache.commons.collections4.list.AbstractLinkedList.LinkedListIterator

      `current, expectedModCount, next, nextIndex, parent`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `Cursor(CursorableLinkedList<E> parent, int index)` Constructs a new cursor.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(E obj)` Adds an object to the list.
    `protected void` | `checkModCount()` Override superclass modCount check, and replace it with our valid flag.
    `void` | `close()` Mark this cursor as no longer being needed.
    `int` | `nextIndex()` Gets the index of the next element to be returned.
    `protected void` | `nodeChanged(AbstractLinkedList.Node<E> node)` Handle event from the list when a node has changed.
    `protected void` | `nodeInserted(AbstractLinkedList.Node<E> node)` Handle event from the list when a node has been added.
    `protected void` | `nodeRemoved(AbstractLinkedList.Node<E> node)` Handle event from the list when a node has been removed.
    `void` | `remove()` Removes the item last returned by this iterator.

    - ### Methods inherited from class org.apache.commons.collections4.list.AbstractLinkedList.LinkedListIterator

      `getLastNodeReturned, hasNext, hasPrevious, next, previous, previousIndex, set`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface java.util.Iterator

      `forEachRemaining`

- - ### Constructor Detail

    - #### Cursor

          protected Cursor(CursorableLinkedList<E> parent,
                           int index)

      Constructs a new cursor.
      Parameters:
        `parent` - the parent list
        `index` - the index to start from

  - ### Method Detail

    - #### remove

          public void remove()

      Removes the item last returned by this iterator.

      There may have been subsequent alterations to the list since you obtained this item, however you can still remove it. You can even remove it if the item is no longer in the main list. However, you can't call this method on the same iterator more than once without calling next() or previous().

      Specified by:
        `remove` in interface `Iterator<E>`
      Specified by:
        `remove` in interface `ListIterator<E>`
      Overrides:
        `remove` in class `AbstractLinkedList.LinkedListIterator<E>`
      Throws:
        `IllegalStateException` - if there is no item to remove

    - #### add

          public void add(E obj)

      Adds an object to the list. The object added here will be the new 'previous' in the iterator.
      Specified by:
        `add` in interface `ListIterator<E>`
      Overrides:
        `add` in class `AbstractLinkedList.LinkedListIterator<E>`
      Parameters:
        `obj` - the object to add

    - #### nextIndex

          public int nextIndex()

      Gets the index of the next element to be returned.
      Specified by:
        `nextIndex` in interface `ListIterator<E>`
      Overrides:
        `nextIndex` in class `AbstractLinkedList.LinkedListIterator<E>`
      Returns:
        the next index

    - #### nodeChanged

          protected void nodeChanged(AbstractLinkedList.Node<E> node)

      Handle event from the list when a node has changed.
      Parameters:
        `node` - the node that changed

    - #### nodeRemoved

          protected void nodeRemoved(AbstractLinkedList.Node<E> node)

      Handle event from the list when a node has been removed.
      Parameters:
        `node` - the node that was removed

    - #### nodeInserted

          protected void nodeInserted(AbstractLinkedList.Node<E> node)

      Handle event from the list when a node has been added.
      Parameters:
        `node` - the node that was added

    - #### checkModCount

          protected void checkModCount()

      Override superclass modCount check, and replace it with our valid flag.
      Overrides:
        `checkModCount` in class `AbstractLinkedList.LinkedListIterator<E>`

    - #### close

          public void close()

      Mark this cursor as no longer being needed. Any resources associated with this cursor are immediately released. In previous versions of this class, it was mandatory to close all cursor objects to avoid memory leaks. It is no longer necessary to call this close method; an instance of this class can now be treated exactly like a normal iterator.

Copyright © 2001–2018 The Apache Software Foundation. All rights reserved.