Package org.apache.commons.collections4.list

Class NodeCachingLinkedList<E>

java.lang.Object
org.apache.commons.collections4.list.AbstractLinkedList<E>
org.apache.commons.collections4.list.NodeCachingLinkedList<E>
All Implemented Interfaces:
Serializable, Iterable<E>, Collection<E>, List<E>
public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements Serializable
A List implementation that stores a cache of internal Node objects in an effort to reduce wasteful object creation.

A linked list creates one Node for each item of data added. This can result in a lot of object creation and garbage collection. This implementation seeks to avoid that by maintaining a store of cached nodes.

This implementation is suitable for long-lived lists where both add and remove are used. Short-lived lists, or lists which only grow will have worse performance using this class.

Note that this implementation is not synchronized.

Since:
3.0
See Also:

  • Constructor Details

    • NodeCachingLinkedList

      public NodeCachingLinkedList()
      Constructor that creates.

    • NodeCachingLinkedList

      public NodeCachingLinkedList(Collection<? extends E> coll)
      Constructor that copies the specified collection
      Parameters:
      coll - the collection to copy

    • NodeCachingLinkedList

      public NodeCachingLinkedList(int maximumCacheSize)
      Constructor that species the maximum cache size.
      Parameters:
      maximumCacheSize - the maximum cache size

  • Method Details

    • addNodeToCache

      protected void addNodeToCache(AbstractLinkedList.Node<E> node)
      Adds a node to the cache, if the cache isn't full. The node's contents are cleared, so they can be garbage collected.
      Parameters:
      node - the node to add to the cache

    • createNode

      protected AbstractLinkedList.Node<E> createNode(E value)
      Creates a new node, either by reusing one from the cache or creating a new one.
      Overrides:
      createNode in class AbstractLinkedList<E>
      Parameters:
      value - value of the new node
      Returns:
      the newly created node

    • getMaximumCacheSize

      protected int getMaximumCacheSize()
      Gets the maximum size of the cache.
      Returns:
      the maximum cache size

    • getNodeFromCache

      protected AbstractLinkedList.Node<E> getNodeFromCache()
      Gets a node from the cache. If a node is returned, then the value of cacheSize is decreased accordingly. The node that is returned will have null values for next, previous and element.
      Returns:
      a node, or null if there are no nodes in the cache.

    • isCacheFull

      protected boolean isCacheFull()
      Checks whether the cache is full.
      Returns:
      true if the cache is full

    • removeAllNodes

      protected void removeAllNodes()
      Removes all the nodes from the list, storing as many as required in the cache for reuse.
      Overrides:
      removeAllNodes in class AbstractLinkedList<E>

    • removeNode

      protected void removeNode(AbstractLinkedList.Node<E> node)
      Removes the node from the list, storing it in the cache for reuse if the cache is not yet full.
      Overrides:
      removeNode in class AbstractLinkedList<E>
      Parameters:
      node - the node to remove

    • setMaximumCacheSize

      protected void setMaximumCacheSize(int maximumCacheSize)
      Sets the maximum size of the cache.
      Parameters:
      maximumCacheSize - the new maximum cache size

    • shrinkCacheToMaximumSize

      protected void shrinkCacheToMaximumSize()
      Reduce the size of the cache to the maximum, if necessary.