Documentation of 'javolution37.javolution.util.FastTable' Java class
FastTable
javolution37.javolution.util

Class FastTable<E>

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>, java.util.RandomAccess, Reusable, Realtime


    public class FastTable<E>
    extends FastCollection<E>
    implements java.util.List<E>, Reusable, java.util.RandomAccess

    This class represents a random access collection with real-time behavior; smooth capacity increase (no array resize/copy ever) and no memory allocation as long as the collection size does not exceed its initial capacity.

    This class has the following advantages over the widely used java.util.ArrayList:

    • Faster when the capacity is unknown (default constructor) as no array resize/copy is ever performed.
    • No large array allocation (for large collections multi-dimensional arrays are employed). Does not stress the garbage collector with large chunk of memory to allocate (likely to trigger a full garbage collection due to memory fragmentation).
    • Support concurrent access/iteration without synchronization if the collection values are not removed/inserted (Ref. javolution37.javolution.util discussion).

    Iterations over the FastTable values are faster when performed using the get(int) method rather than using collection records or iterators:

         for (int i = 0, n = table.size(); i < n; i++) {
              table.get(i);
         }

    FastTable supports sorting in place (quick sort) using the value comparator for the table (no object or array allocation when sorting).

    See Also:
    Serialized Form
    • Constructor Summary

      Constructors 
      Constructor and Description
      FastTable()
      Creates a table of small initial capacity.
      FastTable(java.util.Collection<? extends E> values)
      Creates a table containing the specified values, in the order they are returned by the collection's iterator.
      FastTable(int capacity)
      Creates a table of specified initial capacity; unless the table size reaches the specified capacity, operations on this table will not allocate memory (no lazy object creation).
      FastTable(java.lang.String id)
      Creates a persistent table associated to the specified unique identifier (convenience method).
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method and Description
      boolean add(E value)
      Appends the specified value to the end of this table.
      void add(int index, E value)
      Inserts the specified value at the specified position in this table.
      boolean addAll(int index, java.util.Collection<? extends E> values)
      Inserts all of the values in the specified collection into this table at the specified position.
      void addLast(E value)
      Appends the specified value to the end of this table (fast).
      void clear()
      Removes all of the values from this collection (optional operation).
      void delete(FastCollection.Record record)
      Deletes the specified record from this collection.
      E get(int index)
      Returns the element at the specified index.
      E getFirst()
      Returns the first value of this table.
      E getLast()
      Returns the last value of this table.
      FastCollection.Record head()
      Returns the head record of this collection; it is the record such as head().getNext() holds the first collection value.
      int indexOf(java.lang.Object value)
      Returns the index in this table of the first occurrence of the specified value, or -1 if this table does not contain this value.
      java.util.Iterator<E> iterator()
      Returns an iterator over the elements in this list (allocated on the stack when executed in a PoolContext).
      int lastIndexOf(java.lang.Object value)
      Returns the index in this table of the last occurrence of the specified value, or -1 if this table does not contain this value.
      java.util.ListIterator<E> listIterator()
      Returns a list iterator over the elements in this list (allocated on the stack when executed in a PoolContext).
      java.util.ListIterator<E> listIterator(int index)
      Returns a list iterator from the specified position (allocated on the stack when executed in a PoolContext).
      static <E> FastTable<E> newInstance()
      Returns a table allocated from the "stack" when executing in a PoolContext).
      E remove(int index)
      Removes the value at the specified position from this table.
      E removeLast()
      Removes and returns the last value of this table (fast).
      void removeRange(int fromIndex, int toIndex)
      Removes the values between [fromIndex..toIndex[ from this table.
      void reset()
      Resets the internal state of this object to its default values.
      E set(int index, E value)
      Replaces the value at the specified position in this table with the specified value.
      int size()
      Returns the number of values in this collection.
      void sort()
      Sorts this table in place (quick sort) using this table value comparator.
      java.util.List<E> subList(int fromIndex, int toIndex)
      Returns a view of the portion of this list between the specified indexes (instance of FastList allocated from the "stack" when executing in a PoolContext).
      FastCollection.Record tail()
      Returns the tail record of this collection; it is the record such as tail().getPrevious() holds the last collection value.
      void trimToSize()
      Reduces the capacity of this table to the current size (minimize storage space).
      java.util.List<E> unmodifiable()
      Returns the unmodifiable view associated to this collection.
      E valueOf(FastCollection.Record record)
      Returns the collection value for the specified record.
      • Methods inherited from class java.lang.Object

        getClass, notify, notifyAll, wait, wait, wait
      • Methods inherited from interface java.util.List

        addAll, contains, containsAll, equals, hashCode, isEmpty, remove, removeAll, replaceAll, retainAll, sort, spliterator, toArray, toArray
      • Methods inherited from interface java.util.Collection

        parallelStream, removeIf, stream
      • Methods inherited from interface java.lang.Iterable

        forEach
    • Constructor Detail

      • FastTable

        public FastTable()
        Creates a table of small initial capacity.
      • FastTable

        public FastTable(java.lang.String id)
        Creates a persistent table associated to the specified unique identifier (convenience method).
        Parameters:
        id - the unique identifier for this map.
        Throws:
        java.lang.IllegalArgumentException - if the identifier is not unique.
        See Also:
        PersistentReference
      • FastTable

        public FastTable(int capacity)
        Creates a table of specified initial capacity; unless the table size reaches the specified capacity, operations on this table will not allocate memory (no lazy object creation).
        Parameters:
        capacity - the initial capacity.
      • FastTable

        public FastTable(java.util.Collection<? extends E> values)
        Creates a table containing the specified values, in the order they are returned by the collection's iterator.
        Parameters:
        values - the values to be placed into this table.
    • Method Detail

      • newInstance

        public static <E> FastTable<E> newInstance()
        Returns a table allocated from the "stack" when executing in a PoolContext).
        Returns:
        a new, preallocated or recycled text builder instance.
      • get

        public final E get(int index)
        Returns the element at the specified index.
        Specified by:
        get in interface java.util.List<E>
        Parameters:
        index - index of value to return.
        Returns:
        the value at the specified position in this list.
        Throws:
        java.lang.IndexOutOfBoundsException - if (index < 0) || (index >= size())
      • set

        public final E set(int index,
                           E value)
        Replaces the value at the specified position in this table with the specified value.
        Specified by:
        set in interface java.util.List<E>
        Parameters:
        index - index of value to replace.
        value - value to be stored at the specified position.
        Throws:
        java.lang.IndexOutOfBoundsException - if (index < 0) || (index >= size())
      • add

        public final boolean add(E value)
        Appends the specified value to the end of this table.
        Specified by:
        add in interface java.util.Collection<E>
        Specified by:
        add in interface java.util.List<E>
        Overrides:
        add in class FastCollection<E>
        Parameters:
        value - the value to be appended to this table.
        Returns:
        true (as per the general contract of the Collection.add method).
      • getFirst

        public final E getFirst()
        Returns the first value of this table.
        Returns:
        this table first value.
        Throws:
        java.util.NoSuchElementException - if this table is empty.
      • getLast

        public final E getLast()
        Returns the last value of this table.
        Returns:
        this table last value.
        Throws:
        java.util.NoSuchElementException - if this table is empty.
      • addLast

        public final void addLast(E value)
        Appends the specified value to the end of this table (fast).
        Parameters:
        value - the value to be added.
      • removeLast

        public final E removeLast()
        Removes and returns the last value of this table (fast).
        Returns:
        this table's last value before this call.
        Throws:
        java.util.NoSuchElementException - if this table is empty.
      • clear

        public final void clear()
        Description copied from class: FastCollection
        Removes all of the values from this collection (optional operation).
        Specified by:
        clear in interface java.util.Collection<E>
        Specified by:
        clear in interface java.util.List<E>
        Overrides:
        clear in class FastCollection<E>
      • addAll

        public final boolean addAll(int index,
                                    java.util.Collection<? extends E> values)
        Inserts all of the values in the specified collection into this table at the specified position. Shifts the value currently at that position (if any) and any subsequent values to the right (increases their indices).
        Specified by:
        addAll in interface java.util.List<E>
        Parameters:
        index - the index at which to insert first value from the specified collection.
        values - the values to be inserted into this list.
        Returns:
        true if this list changed as a result of the call; false otherwise.
        Throws:
        java.lang.IndexOutOfBoundsException - if (index < 0) || (index > size())
      • add

        public final void add(int index,
                              E value)
        Inserts the specified value at the specified position in this table. Shifts the value currently at that position (if any) and any subsequent values to the right (adds one to their indices).
        Specified by:
        add in interface java.util.List<E>
        Parameters:
        index - the index at which the specified value is to be inserted.
        value - the value to be inserted.
        Throws:
        java.lang.IndexOutOfBoundsException - if (index < 0) || (index > size())
      • remove

        public final E remove(int index)
        Removes the value at the specified position from this table. Shifts any subsequent values to the left (subtracts one from their indices). Returns the value that was removed from the table.
        Specified by:
        remove in interface java.util.List<E>
        Parameters:
        index - the index of the value to removed.
        Returns:
        the value previously at the specified position.
        Throws:
        java.lang.IndexOutOfBoundsException - if (index < 0) || (index >= size())
      • removeRange

        public final void removeRange(int fromIndex,
                                      int toIndex)
        Removes the values between [fromIndex..toIndex[ from this table.
        Parameters:
        fromIndex - the beginning index, inclusive.
        toIndex - the ending index, exclusive.
        Throws:
        java.lang.IndexOutOfBoundsException - if (fromIndex < 0) || (toIndex < 0) || (fromIndex > toIndex) || (toIndex > this.size())
      • indexOf

        public final int indexOf(java.lang.Object value)
        Returns the index in this table of the first occurrence of the specified value, or -1 if this table does not contain this value.
        Specified by:
        indexOf in interface java.util.List<E>
        Parameters:
        value - the value to search for.
        Returns:
        the index in this table of the first occurrence of the specified value, or -1 if this table does not contain this value.
      • lastIndexOf

        public final int lastIndexOf(java.lang.Object value)
        Returns the index in this table of the last occurrence of the specified value, or -1 if this table does not contain this value.
        Specified by:
        lastIndexOf in interface java.util.List<E>
        Parameters:
        value - the value to search for.
        Returns:
        the index in this table of the last occurrence of the specified value, or -1 if this table does not contain this value.
      • iterator

        public final java.util.Iterator<E> iterator()
        Returns an iterator over the elements in this list (allocated on the stack when executed in a PoolContext).
        Specified by:
        iterator in interface java.lang.Iterable<E>
        Specified by:
        iterator in interface java.util.Collection<E>
        Specified by:
        iterator in interface java.util.List<E>
        Overrides:
        iterator in class FastCollection<E>
        Returns:
        an iterator over this list values.
      • listIterator

        public final java.util.ListIterator<E> listIterator()
        Returns a list iterator over the elements in this list (allocated on the stack when executed in a PoolContext).
        Specified by:
        listIterator in interface java.util.List<E>
        Returns:
        an iterator over this list values.
      • listIterator

        public final java.util.ListIterator<E> listIterator(int index)
        Returns a list iterator from the specified position (allocated on the stack when executed in a PoolContext). The list iterator being returned does not support insertion/deletion.
        Specified by:
        listIterator in interface java.util.List<E>
        Parameters:
        index - the index of first value to be returned from the list iterator (by a call to the next method).
        Returns:
        a list iterator of the values in this table starting at the specified position in this list.
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range
        (index < 0 || index > size())
      • subList

        public final java.util.List<E> subList(int fromIndex,
                                               int toIndex)
        Returns a view of the portion of this list between the specified indexes (instance of FastList allocated from the "stack" when executing in a PoolContext). If the specified indexes are equal, the returned list is empty. The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of values from a list:
         list.subList(from, to).clear();
        Similar idioms may be constructed for indexOf and lastIndexOf, and all of the algorithms in the Collections class can be applied to a subList. The semantics of the list returned by this method become undefined if the backing list (i.e., this list) is structurally modified in any way other than via the returned list (structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results).
        Specified by:
        subList in interface java.util.List<E>
        Parameters:
        fromIndex - low endpoint (inclusive) of the subList.
        toIndex - high endpoint (exclusive) of the subList.
        Returns:
        a view of the specified range within this list.
        Throws:
        java.lang.IndexOutOfBoundsException - if
        (fromIndex < 0 ||
                  toIndex > size || fromIndex > toIndex)
      • trimToSize

        public final void trimToSize()
        Reduces the capacity of this table to the current size (minimize storage space).
      • sort

        public final void sort()
        Sorts this table in place (quick sort) using this table value comparator.
      • size

        public final int size()
        Description copied from class: FastCollection
        Returns the number of values in this collection.
        Specified by:
        size in interface java.util.Collection<E>
        Specified by:
        size in interface java.util.List<E>
        Specified by:
        size in class FastCollection<E>
        Returns:
        the number of values.
      • head

        public final FastCollection.Record head()
        Description copied from class: FastCollection
        Returns the head record of this collection; it is the record such as head().getNext() holds the first collection value.
        Specified by:
        head in class FastCollection<E>
        Returns:
        the head record.
      • tail

        public final FastCollection.Record tail()
        Description copied from class: FastCollection
        Returns the tail record of this collection; it is the record such as tail().getPrevious() holds the last collection value.
        Specified by:
        tail in class FastCollection<E>
        Returns:
        the tail record.
      • valueOf

        public final E valueOf(FastCollection.Record record)
        Description copied from class: FastCollection
        Returns the collection value for the specified record.
        Specified by:
        valueOf in class FastCollection<E>
        Parameters:
        record - the record whose current value is returned.
        Returns:
        the current value.
      • delete

        public final void delete(FastCollection.Record record)
        Description copied from class: FastCollection
        Deletes the specified record from this collection.

        Implementation must ensure that removing a record from the collection does not affect in any way the records preceding the record being removed (it might affect the next records though, e.g. in a list collection, the indices of the subsequent records will change).

        Specified by:
        delete in class FastCollection<E>
        Parameters:
        record - the record to be removed.
      • reset

        public void reset()
        Description copied from interface: Reusable
        Resets the internal state of this object to its default values.
        Specified by:
        reset in interface Reusable
      • unmodifiable

        public java.util.List<E> unmodifiable()
        Description copied from class: FastCollection
        Returns the unmodifiable view associated to this collection. Attempts to modify the returned collection result in an UnsupportedOperationException being thrown. The view is typically part of the collection itself (created only once) and also an instance of FastCollection supporting direct iterations.
        Overrides:
        unmodifiable in class FastCollection<E>
        Returns:
        the unmodifiable view over this collection.

DMelt 3.0 © DataMelt by jWork.ORG

You see the box below because you did not login.