Package org.apache.commons.collections4.list

Class 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:
    Serialized Form

    • Constructor Detail

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

      • getMaximumCacheSize

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

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

      • 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

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

      • 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

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