java.lang.Object
org.magicwerk.brownies.collections.primitive.IFloatList
Record Components:
type - of elements stored in the list
All Implemented Interfaces:
Serializable, Cloneable, IFloatListable
Direct Known Subclasses:
FloatBigList, FloatGapList

public abstract class IFloatList extends Object implements IFloatListable, Cloneable, Serializable
Class IFloatList is the abstract class which offers all interfaces implemented by ArrayList. It also offers additional methods which are then available in all implementations of GapList and
invalid reference
BigList
.
See Also:
  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    protected static class 
    Wrapper to treat an array as IFloatListable.
    protected static class 
    Wrapper to treat a Collection as IFloatListable.
    protected static class 
    Wrapper to treat a List as IFloatListable.
    protected static class 
    Wrapper to treat a repeated element as IFloatListable.
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    private static final int
     
    private static final int
     
    private static final int
     
  • Constructor Summary

    Constructors
    Constructor
    Description
     
  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    add(float elem)
     
    void
    add(int index, float elem)
    Inserts the specified element at the specified position in this list.
    boolean
    addAll(int index, Collection<Float> coll)
    Inserts all of the elements in the specified collection into this list, starting at the specified position.
    boolean
    addAll(int index, IFloatList list)
    Inserts all of the elements in the specified list into this list, starting at the specified position.
    boolean
    Adds all of the elements in the specified collection into this list.
    boolean
    Adds all of the elements in the specified list into this list.
    boolean
    addArray(float... elems)
    Adds all specified elements into this list.
    boolean
    addArray(float[] elems, int offset, int length)
     
    boolean
    addArray(int index, float... elems)
    Inserts the specified elements into this list, starting at the specified position.
    boolean
    addArray(int index, float[] elems, int offset, int length)
     
    void
    addFirst(float elem)
    boolean
    addIfAbsent(float elem)
     
    void
    addLast(float elem)
    boolean
    addMult(int len, float elem)
    Adds element multiple time to list.
    boolean
    addMult(int index, int len, float elem)
    Inserts element multiple time to list, starting at the specified position.
    protected IFloatListable
    Return correct IFloatListable for passed collection.
    int
    binarySearch(float key)
    Searches the specified range for an object using the binary* search algorithm.
    abstract int
    binarySearch(int index, int len, float key)
    Searches the specified range for an object using the binary search algorithm.
    abstract int
    Returns capacity of this list.
    protected void
    checkIndex(int index)
    Check that specified index is valid for getting/setting elements.
    protected void
    checkIndexAdd(int index)
    Check that specified index is valid for adding elements.
    protected void
    checkLength(int len)
    Check that specified length is valid (>= 0).
    protected void
    checkLengths(int len1, int len2)
    Check that both specified lengths are valid (>= 0) and equal.
    protected void
    Check that object is not null.
    protected void
    checkRange(int index, int len)
    Check that specified range is valid.
    void
     
    Returns a shallow copy of this list.
    boolean
    contains(float elem)
     
    boolean
     
    boolean
    Returns true if any of the elements of the specified collection is contained in the list.
    boolean
    Determines whether the list contains a matching element.
    abstract IFloatList
    Returns a shallow copy of this list.
    void
    copy(int srcIndex, int dstIndex, int len)
    Copy specified elements.
    int
    count(float elem)
     
    int
    countIf(Predicate<Float> predicate)
     
    Returns a copy this list but without elements.
    protected abstract boolean
    doAdd(int index, float elem)
    Helper method for adding an element to the list.
    protected boolean
    doAddAll(int index, IFloatListable list)
    Helper method for adding multiple elements to the list.
    protected abstract void
    Assign this list the content of the that list.
    protected void
     
    protected abstract void
    Initialize this object after the bitwise copy has been made by Object.clone().
    protected abstract IFloatList
    doCreate(int capacity)
    Create list with specified capacity.
    protected float[]
    doCreateArray(Class clazz, int len)
    Create array.
    protected abstract void
    doEnsureCapacity(int minCapacity)
    Increases the capacity of this list instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
    protected abstract float
    doGet(int index)
    Helper method for getting an element from the list.
    protected void
    doGetAll(float[] array, int index, int len)
    Helper method to fill the specified elements in an array.
    protected int
    doIndexOf(float elem, int fromIndex)
    Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position.
    protected int
    doIndexOfIf(Predicate<Float> predicate, int fromIndex)
    Returns the index of the first element which matches the specified predicate in this list, starting the search at the specified position.
    protected void
     
    protected int
    doLastIndexOf(float elem, int fromIndex)
    Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position.
    protected int
    doLastIndexOfIf(Predicate<Float> predicate, int fromIndex)
    Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position.
    protected void
    This method is called internally before elements are allocated or freed.
    protected void
    doPutAll(int index, IFloatListable list)
     
    protected abstract float
    doRemove(int index)
    Helper method to remove an element.
    protected void
    doRemoveAll(int index, int len)
    Remove specified range of elements from list.
    protected boolean
    doReplace(int index, int len, IFloatListable list)
     
    protected abstract float
    doReSet(int index, float elem)
    Sets an element at specified position.
    protected void
    doRotate(int index, int len, int distance)
    Internal method to rotate specified elements in the list.
    protected abstract float
    doSet(int index, float elem)
    Helper method for setting an element in the list.
    (package private) void
    doTransfer(int transferMode, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
     
    (package private) void
    doTransferSwap(int srcIndex, IFloatList dst, int dstIndex, int len)
     
    void
    drag(int srcIndex, int dstIndex, int len)
    Drag specified elements.
    float
    void
    ensureCapacity(int minCapacity)
     
    boolean
     
    (package private) static boolean
    equalsElem(float elem1, float elem2)
    Helper function to check two elements stored in the list for equality.
    extract(int index, int len)
    Removes specified range of elements from list and return them.
    Removes and returns all elements in the list which match the predicate.
    void
    fill(float elem)
     
    filter(Predicate<Float> predicate)
    Create a new list by applying the specified filter to all elements.
    <R> IList<R>
    filterMap(Predicate<Float> filter, Function<Float,R> func)
     
    <R, C extends Collection<R>>
    IList<R>
     
    float
    get(int index)
     
    getAll(float elem)
    Returns all elements in the list equal to the specified element.
    getAll(int index, int len)
    Returns specified range of elements from list.
    protected abstract float
     
    Returns distinct elements in the list.
    float
     
    float
     
    float
    getIf(Predicate<Float> predicate)
    Get first element in the list which matches the predicate.
    float
    float
    Returns the last element stored in the list.
    float
     
    float
     
    int
     
    (package private) static int
    hashCodeElem(float elem)
    Helper method to calculate hash code of a element stored in the list.
    abstract IFloatList
    Returns an immutable copy of this list.
    int
    indexOf(float elem)
     
    int
    indexOf(float elem, int fromIndex)
    Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position.
    int
    Returns the index of the first element which matches the specified predicate in this list.
    int
    indexOfIf(Predicate<Float> predicate, int fromIndex)
    Returns the index of the first element which matches the specified predicate in this list, starting the search at the specified position.
    void
    Initializes the list so it will afterwards only contain the elements of the collection.
    void
    Initializes the list so it will afterwards only contain the elements of the collection.
    void
    initArray(float... elems)
    Initializes the list so it will afterwards only contain the elements of the array.
    void
    initMult(int len, float elem)
    Initializes the list so it will afterwards have a size of len and contain only the element elem.
    boolean
     
    abstract boolean
    Returns true if this list is either unmodifiable or immutable, false otherwise.
    int
    lastIndexOf(float elem)
     
    int
    lastIndexOf(float elem, int fromIndex)
    Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position.
    int
    Returns the index of the last element which matches the specified predicate in this list.
    int
    lastIndexOfIf(Predicate<Float> predicate, int fromIndex)
    Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position.
    <R> IList<R>
    map(Function<Float,R> func)
     
    <R> IList<R>
    mapFilter(Function<Float,R> func, Predicate<R> filter)
     
    void
    move(int srcIndex, int dstIndex, int len)
    Move specified elements.
    boolean
    offer(float elem)
    boolean
    offerFirst(float elem)
    boolean
    offerLast(float elem)
    float
    float
    float
    float
    float
    float
    float
    pop()
    void
    push(float elem)
    float
    put(int index, float elem)
    Sets or adds the element.
    void
    putAll(int index, Collection<Float> coll)
    Set or add the specified elements.
    void
    putAll(int index, IFloatList list)
    Set or add the specified elements.
    void
    putArray(int index, float... elems)
    Set or add the specified elements.
    void
    putMult(int index, int len, float elem)
    Set or add the specified element multiple times.
    float
    float
    remove(int index)
     
    void
    remove(int index, int len)
    Remove specified range of elements from list.
    removeAll(float elem)
    Removes all equal elements.
    boolean
     
    boolean
     
    boolean
    removeElem(float elem)
     
    float
    boolean
    boolean
    removeIf(Predicate<Float> predicate)
    Removes all elements in the list which match the predicate.
    float
    boolean
    protected void
    replace(int index, int len, IFloatListable list)
     
    void
    replaceAll(int index, int len, Collection<Float> coll)
    Replaces the specified range with new elements.
    void
    replaceAll(int index, int len, IFloatList list)
    Replaces the specified range with new elements.
    void
    replaceArray(int index, int len, float... elems)
    Replaces the specified range with new elements.
    void
    replaceMult(int index, int len, int numElems, float elem)
    Replaces the specified range with new elements.
    void
    resize(int len, float elem)
    Resizes the list so it will afterwards have a size of len.
    void
    retain(int index, int len)
    Retain specified range of elements from list, the other elements are removed.
    boolean
     
    boolean
     
    boolean
    retainIf(Predicate<Float> predicate)
    Retains all elements in the list which match the predicate.
    void
    Reverses the order of all elements in the specified list.
    void
    reverse(int index, int len)
    Reverses the order of the specified elements in the list.
    void
    rotate(int distance)
    Rotate specified elements in the list.
    void
    rotate(int index, int len, int distance)
    Rotate specified elements in the list.
    float
    set(int index, float elem)
     
    void
    setAll(int index, Collection<Float> coll)
    Sets the specified elements.
    void
    setAll(int index, IFloatList list)
    Sets the specified elements.
    void
    setArray(int index, float... elems)
    Sets the specified elements.
    void
    setArray(int index, float[] elems, int offset, int length)
     
    void
    setMult(int index, int len, float elem)
    Sets the element multiple times.
    abstract int
     
    void
    Sort elements in the list using the specified comparator.
    abstract void
    sort(int index, int len)
    Sort specified elements in the list using the specified comparator.
    void
    swap(int index1, int index2, int len)
    Swap the specified elements in the list.
    float[]
     
    float[]
    toArray(float[] array)
     
    float[]
    toArray(float[] array, int index, int len)
    Returns an array containing the specified elements in this list.
    float[]
    toArray(int index, int len)
    Returns an array containing the specified elements in this list.
    float[]
    toArray(Class clazz)
    Returns an array containing the elements in this list.
    float[]
    toArray(Class clazz, int index, int len)
    Returns an array containing the specified elements in this list.
    (package private) static float[]
    Copies the collection values into an array.
     
    static void
    transferCopy(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
    Copies elements from one list to another.
    static void
    transferMove(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
    Moves elements from one list to another by setting it to null in the source list.
    static void
    transferRemove(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
    Moves elements from one list to another by removing it from the source list.
    static void
    transferSwap(IFloatList src, int srcIndex, IFloatList dst, int dstIndex, int len)
    Swaps elements from two lists.
    void
    Change the list by applying the specified operator to all elements.
    Create a new list by applying the specified transforming operator to all elements.
    abstract void
     
    abstract IFloatList
     

    Methods inherited from class java.lang.Object

    finalize, getClass, notify, notifyAll, wait, wait, wait
  • Field Details

  • Constructor Details

    • IFloatList

      public IFloatList()
  • Method Details

    • toArray

      static float[] toArray(Collection<Float> coll)
      Copies the collection values into an array.
      Parameters:
      coll - collection of values
      Returns:
      array containing the collection values
    • copy

      public abstract IFloatList copy()
      Returns a shallow copy of this list. The new list will contain the same elements as the source list, i.e. the elements themselves are not copied. The capacity of the list will be set to the number of elements, i.e. size and capacity are equal. This returned list will be modifiable, i.e. a read-only list will be copied and be modifiable again.
      Returns:
      a modifiable copy of this list
    • clone

      public IFloatList clone()
      Returns a shallow copy of this list. The new list will contain the same elements as the source list, i.e. the elements themselves are not copied. The capacity of the list will be set to the number of elements, i.e. size and capacity are equal. If the list is read-only, the same list is returned without change. Use copy() to .
      Overrides:
      clone in class Object
      Returns:
      a modifiable copy of this list
    • crop

      public IFloatList crop()
      Returns a copy this list but without elements. The new list will have the same type as this list.
      Returns:
      an empty copy of this list
    • isReadOnly

      public abstract boolean isReadOnly()
      Returns true if this list is either unmodifiable or immutable, false otherwise.
    • unmodifiableList

      public abstract IFloatList unmodifiableList()
    • immutableList

      public abstract IFloatList immutableList()
      Returns an immutable copy of this list. The returned list is independent from the original list, i.e. changes done later are not seen. Attempts to modify the returned list, whether direct or via its iterator, result in an UnsupportedOperationException. If this list is already immutable, it is returned unchanged. See unmodifiableList() to get unmodifiable view of a list.
      Returns:
      an immutable copy of the specified list
    • doClone

      protected abstract void doClone(IFloatList that)
      Initialize this object after the bitwise copy has been made by Object.clone().
      Parameters:
      that - source object
    • clear

      public void clear()
    • doClear

      protected void doClear()
    • resize

      public void resize(int len, float elem)
      Resizes the list so it will afterwards have a size of len. If the list must grow, the specified element elem will be used for filling.
      Parameters:
      len - new size of list
      elem - element which will be used for extending the list
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • size

      public abstract int size()
      Specified by:
      size in interface IFloatListable
    • capacity

      public abstract int capacity()
      Returns capacity of this list. Note that two lists are considered equal even if they have a distinct capacity. Also the capacity can be changed by operations like clone() etc.
      Returns:
      capacity of this list
    • get

      public float get(int index)
      Specified by:
      get in interface IFloatListable
    • doGet

      protected abstract float doGet(int index)
      Helper method for getting an element from the list. This is the only method which really gets an element. Override if you need to validity checks before getting.
      Parameters:
      index - index of element to return
      Returns:
      the element at the specified position in this list
    • doSet

      protected abstract float doSet(int index, float elem)
      Helper method for setting an element in the list. This is the only method which really sets an element. Override if you need to validity checks before setting.
      Parameters:
      index - index where element will be placed
      elem - element to set
      Returns:
      old element which was at the position
    • set

      public float set(int index, float elem)
    • put

      public float put(int index, float elem)
      Sets or adds the element. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.
      Parameters:
      index - index where element will be placed
      elem - element to put
      Returns:
      old element if an element was replaced, null if the element was added
      Throws:
      IndexOutOfBoundsException - if the index is out of range (index < 0 || index > size())
    • doReSet

      protected abstract float doReSet(int index, float elem)
      Sets an element at specified position. This method is used internally if existing elements will be moved etc. Override if you need to validity checks.
      Parameters:
      index - index where element will be placed
      elem - element to set
      Returns:
      old element which was at the position
    • getDefaultElem

      protected abstract float getDefaultElem()
    • doModify

      protected void doModify()
      This method is called internally before elements are allocated or freed. Override if you need to validity checks.
    • add

      public boolean add(float elem)
    • add

      public void add(int index, float elem)
      Inserts the specified element at the specified position in this list. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
      Parameters:
      index - index at which the specified element is to be inserted
      elem - element to be inserted
    • doAdd

      protected abstract boolean doAdd(int index, float elem)
      Helper method for adding an element to the list. This is the only method which really adds an element. Override if you need to validity checks before adding.
      Parameters:
      index - index where element should be added (-1 means it is up to the implementation to choose the index)
      elem - element to add
      Returns:
      true if element has been added, false otherwise
    • remove

      public float remove(int index)
    • doRemove

      protected abstract float doRemove(int index)
      Helper method to remove an element. This is the only method which really removes an element. Override if you need to validity checks before removing.
      Parameters:
      index - index of element to remove
      Returns:
      removed element
    • ensureCapacity

      public void ensureCapacity(int minCapacity)
    • doEnsureCapacity

      protected abstract void doEnsureCapacity(int minCapacity)
      Increases the capacity of this list instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
      Parameters:
      minCapacity - the desired minimum capacity
    • trimToSize

      public abstract void trimToSize()
    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object
    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object
    • toString

      public String toString()
      Overrides:
      toString in class Object
    • isEmpty

      public boolean isEmpty()
    • equalsElem

      static boolean equalsElem(float elem1, float elem2)
      Helper function to check two elements stored in the list for equality.
      Parameters:
      elem1 - first element
      elem2 - second element
      Returns:
      true if the elements are equal, otherwise false
    • hashCodeElem

      static int hashCodeElem(float elem)
      Helper method to calculate hash code of a element stored in the list.
      Parameters:
      elem - element
      Returns:
      hash code for element
    • count

      public int count(float elem)
    • countIf

      public int countIf(Predicate<Float> predicate)
    • getSingle

      public float getSingle()
    • getSingleOrNull

      public float getSingleOrNull()
    • getAll

      public IFloatList getAll(float elem)
      Returns all elements in the list equal to the specified element.
      Parameters:
      elem - element to look for
      Returns:
      all elements in the list equal to the specified element
    • getIf

      public float getIf(Predicate<Float> predicate)
      Get first element in the list which matches the predicate.
      Parameters:
      predicate - a predicate which returns true for elements to be selected
      Returns:
      first element matching the predicate, null otherwise
    • getDistinct

      public Set<Float> getDistinct()
      Returns distinct elements in the list.
      Returns:
      distinct elements in the list
    • map

      public <R> IList<R> map(Function<Float,R> func)
    • flatMap

      public <R, C extends Collection<R>> IList<R> flatMap(Function<Float,C> func)
    • mapFilter

      public <R> IList<R> mapFilter(Function<Float,R> func, Predicate<R> filter)
    • filterMap

      public <R> IList<R> filterMap(Predicate<Float> filter, Function<Float,R> func)
    • transformedList

      public IFloatList transformedList(UnaryOperator<Float> op)
      Create a new list by applying the specified transforming operator to all elements.
      Parameters:
      op - transforming operator
      Returns:
      created list
    • transform

      public void transform(UnaryOperator<Float> op)
      Change the list by applying the specified operator to all elements.
      Parameters:
      op - transforming operator
    • filter

      public IFloatList filter(Predicate<Float> predicate)
      Create a new list by applying the specified filter to all elements. Only element which are allowed by the predicate are copied to the new list.
      Parameters:
      predicate - predicate used for filtering
      Returns:
      created list
    • retainIf

      public boolean retainIf(Predicate<Float> predicate)
      Retains all elements in the list which match the predicate.
      Parameters:
      predicate - a predicate which returns true for elements to be retained
      Returns:
      true if the list was changed
    • removeIf

      public boolean removeIf(Predicate<Float> predicate)
      Removes all elements in the list which match the predicate.
      Parameters:
      predicate - a predicate which returns true for elements to be removed
      Returns:
      true if the list was changed
    • extractIf

      public IFloatList extractIf(Predicate<Float> predicate)
      Removes and returns all elements in the list which match the predicate.
      Parameters:
      predicate - predicate
      Returns:
      elements which have been removed from the list
    • indexOf

      public int indexOf(float elem)
    • indexOf

      public int indexOf(float elem, int fromIndex)
      Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
      Parameters:
      elem - element to search for
      fromIndex - start index for search
      Returns:
      the index of the first occurrence of the specified element in this list that is greater than or equal to fromIndex, or -1 if this list does not contain the element
      See Also:
      • invalid reference
        #indexOf(Object)
    • doIndexOf

      protected int doIndexOf(float elem, int fromIndex)
      Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
    • indexOfIf

      public int indexOfIf(Predicate<Float> predicate)
      Returns the index of the first element which matches the specified predicate in this list. If no such element is not found, -1 is returned.
      Parameters:
      predicate - predicate used to search for the element
      Returns:
      the index of the first element which matches the specified predicate, or -1 if not found
      See Also:
      • invalid reference
        #indexOf(Object)
    • indexOfIf

      public int indexOfIf(Predicate<Float> predicate, int fromIndex)
      Returns the index of the first element which matches the specified predicate in this list, starting the search at the specified position. If no such element is not found, -1 is returned.
      Parameters:
      predicate - predicate used to search for the element
      Returns:
      the index of the first element which matches the specified predicate, or -1 if not found
      See Also:
      • invalid reference
        #indexOf(Object)
    • doIndexOfIf

      protected int doIndexOfIf(Predicate<Float> predicate, int fromIndex)
      Returns the index of the first element which matches the specified predicate in this list, starting the search at the specified position. If no such element is not found, -1 is returned.
    • lastIndexOf

      public int lastIndexOf(float elem)
    • lastIndexOf

      public int lastIndexOf(float elem, int fromIndex)
      Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
      Parameters:
      elem - element to search for
      fromIndex - start index for search
      Returns:
      the index of the last occurrence of the specified element in this list that is less than or equal to fromIndex, or -1 if this list does not contain the element
      See Also:
      • invalid reference
        #lastIndexOf(Object)
    • doLastIndexOf

      protected int doLastIndexOf(float elem, int fromIndex)
      Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
    • lastIndexOfIf

      public int lastIndexOfIf(Predicate<Float> predicate)
      Returns the index of the last element which matches the specified predicate in this list. If no such element is not found, -1 is returned.
      Parameters:
      predicate - predicate used to search for the element
      Returns:
      the index of the last element which matches the specified predicate, or -1 if not found
      See Also:
      • invalid reference
        #lastIndexOf(Object)
    • lastIndexOfIf

      public int lastIndexOfIf(Predicate<Float> predicate, int fromIndex)
      Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
      Parameters:
      predicate - predicate used to search for the element
      fromIndex - start index for search
      Returns:
      the index of the last occurrence of the specified element in this list that is less than or equal to fromIndex, or -1 if this list does not contain the element
      See Also:
      • invalid reference
        #lastIndexOf(Object)
    • doLastIndexOfIf

      protected int doLastIndexOfIf(Predicate<Float> predicate, int fromIndex)
      Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.
    • removeElem

      public boolean removeElem(float elem)
    • contains

      public boolean contains(float elem)
    • containsIf

      public boolean containsIf(Predicate<Float> predicate)
      Determines whether the list contains a matching element.
      Parameters:
      predicate - predicate used to search element
      Returns:
      true if the list contains a matching element, false otherwise
    • addIfAbsent

      public boolean addIfAbsent(float elem)
    • containsAny

      public boolean containsAny(Collection<Float> coll)
      Returns true if any of the elements of the specified collection is contained in the list.
      Parameters:
      coll - collection with elements to be contained
      Returns:
      true if any element is contained, false otherwise
    • containsAll

      public boolean containsAll(Collection<Float> coll)
    • removeAll

      public IFloatList removeAll(float elem)
      Removes all equal elements.
      Parameters:
      elem - element
      Returns:
      removed equal elements (never null)
    • removeAll

      public boolean removeAll(Collection<Float> coll)
    • removeAll

      public boolean removeAll(IFloatList coll)
      See Also:
    • retainAll

      public boolean retainAll(Collection<Float> coll)
    • retainAll

      public boolean retainAll(IFloatList coll)
      See Also:
    • toArray

      public float[] toArray()
    • toArray

      public float[] toArray(float[] array)
    • toArray

      public float[] toArray(Class clazz)
      Returns an array containing the elements in this list.
      Parameters:
      clazz - class for array elements
      Returns:
      array containing the specified elements
    • toArray

      public float[] toArray(int index, int len)
      Returns an array containing the specified elements in this list.
      Parameters:
      index - index of first element to copy
      len - number of elements to copy
      Returns:
      array containing the specified elements
      See Also:
    • toArray

      public float[] toArray(float[] array, int index, int len)
      Returns an array containing the specified elements in this list.
      Parameters:
      array - the array into which the elements of this list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose
      index - index of first element to copy
      len - number of elements to copy
      Returns:
      array containing the specified elements
      See Also:
    • toArray

      public float[] toArray(Class clazz, int index, int len)
      Returns an array containing the specified elements in this list.
      Parameters:
      clazz - class for array elements
      index - index of first element to copy
      len - number of elements to copy
      Returns:
      array containing the specified elements
    • doCreateArray

      protected float[] doCreateArray(Class clazz, int len)
      Create array.
      Parameters:
      clazz - class for array elements
      len - array length
      Returns:
      created array
    • doGetAll

      protected void doGetAll(float[] array, int index, int len)
      Helper method to fill the specified elements in an array.
      Type Parameters:
      T - type of elements stored in the list
      Parameters:
      array - array to store the list elements
      index - index of first element to copy
      len - number of elements to copy
    • doAddAll

      protected boolean doAddAll(int index, IFloatListable list)
      Helper method for adding multiple elements to the list. This default implementation calls doAdd() for adding each element.
      Parameters:
      index - index where element should be added (-1 is valid for adding at the end)
      list - list with elements to add
      Returns:
      true if elements have been added, false otherwise
    • peek

      public float peek()
    • element

      public float element()
    • poll

      public float poll()
    • remove

      public float remove()
    • offer

      public boolean offer(float elem)
    • getFirst

      public float getFirst()
    • getFirstOrNull

      public float getFirstOrNull()
    • getLast

      public float getLast()
    • getLastOrNull

      public float getLastOrNull()
      Returns the last element stored in the list. If the list is empty, null is returned.
      Returns:
      last element stored in the list or null if empty
    • addFirst

      public void addFirst(float elem)
    • addLast

      public void addLast(float elem)
    • removeFirst

      public float removeFirst()
    • removeLast

      public float removeLast()
    • offerFirst

      public boolean offerFirst(float elem)
    • offerLast

      public boolean offerLast(float elem)
    • peekFirst

      public float peekFirst()
    • peekLast

      public float peekLast()
    • pollFirst

      public float pollFirst()
    • pollLast

      public float pollLast()
    • pop

      public float pop()
    • push

      public void push(float elem)
    • removeFirstOccurrence

      public boolean removeFirstOccurrence(float elem)
    • removeLastOccurrence

      public boolean removeLastOccurrence(float elem)
    • transferCopy

      public static void transferCopy(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
      Copies elements from one list to another. Elements and size of source list do not change. The elements in the specified range in the destination list are removed and the elements specified to be copied are inserted. If source and destination list are identical, the method behaves like copy(int, int, int).
      Parameters:
      src - source list
      srcIndex - index of first element in source list
      srcLen - number of elements to copy
      dst - destination list
      dstIndex - index of first element in destination list
      dstLen - number of elements to replace in destination list
      type - of elements stored in the list
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • transferMove

      public static void transferMove(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
      Moves elements from one list to another by setting it to null in the source list. Elements in the source range are set to null, but size of source list does not change. The elements in the specified range in the destination list are removed and the elements specified to be moved are inserted. If source and destination list are identical, the method behaves like move(int, int, int).
      Parameters:
      src - source list
      srcIndex - index of first element in source list
      srcLen - number of elements to copy
      dst - destination list
      dstIndex - index of first element in destination list
      dstLen - number of elements to replace in destination list
      type - of elements stored in the list
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • transferRemove

      public static void transferRemove(IFloatList src, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
      Moves elements from one list to another by removing it from the source list. So the size of source list will change. The elements in the specified range in the destination list are removed and the elements specified to be moved are inserted. If source and destination list are identical, the method behaves like drag(int, int, int).
      Parameters:
      src - source list
      srcIndex - index of first element in source list
      srcLen - number of elements to copy
      dst - destination list
      dstIndex - index of first element in destination list
      dstLen - number of elements to replace in destination list
      type - of elements stored in the list
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • doTransfer

      void doTransfer(int transferMode, int srcIndex, int srcLen, IFloatList dst, int dstIndex, int dstLen)
    • transferSwap

      public static void transferSwap(IFloatList src, int srcIndex, IFloatList dst, int dstIndex, int len)
      Swaps elements from two lists. The size of both source and destination list do not change. If source and destination list are identical, the method behaves like swap(int, int, int).
      Parameters:
      src - first list
      srcIndex - index of first element in first list
      dst - second list
      dstIndex - index of first element in second list
      len - number of elements to swap
      type - of elements stored in the list
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • doTransferSwap

      void doTransferSwap(int srcIndex, IFloatList dst, int dstIndex, int len)
    • doCreate

      protected abstract IFloatList doCreate(int capacity)
      Create list with specified capacity.
      Parameters:
      capacity - initial capacity (use -1 for default capacity)
      Returns:
      created list
    • doAssign

      protected abstract void doAssign(IFloatList that)
      Assign this list the content of the that list. This is done by bitwise copying so the that list should not be used afterwards.
      Parameters:
      that - list to copy content from
    • getAll

      public IFloatList getAll(int index, int len)
      Returns specified range of elements from list.
      Parameters:
      index - index of first element to retrieve
      len - number of elements to retrieve
      Returns:
      list containing the specified range of elements
    • extract

      public IFloatList extract(int index, int len)
      Removes specified range of elements from list and return them.
      Parameters:
      index - index of first element to retrieve
      len - number of elements to retrieve
      Returns:
      list containing the specified range of elements
    • retain

      public void retain(int index, int len)
      Retain specified range of elements from list, the other elements are removed.
      Parameters:
      index - index of first element to retain
      len - number of elements to retain
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • remove

      public void remove(int index, int len)
      Remove specified range of elements from list.
      Parameters:
      index - index of first element to remove
      len - number of elements to remove
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • doRemoveAll

      protected void doRemoveAll(int index, int len)
      Remove specified range of elements from list.
      Parameters:
      index - index of first element to remove
      len - number of elements to remove
    • addAll

      public boolean addAll(IFloatList list)
      Adds all of the elements in the specified list into this list.
      Parameters:
      list - collection containing elements to be added to this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      NullPointerException - if the specified list is null
    • addAll

      public boolean addAll(int index, IFloatList list)
      Inserts all of the elements in the specified list into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices).
      Parameters:
      index - index at which to insert the first element from the specified collection
      list - list containing elements to be inserted into this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      IndexOutOfBoundsException - if the index is invalid
      NullPointerException - if the specified collection is null
    • addAll

      public boolean addAll(Collection<Float> coll)
      Adds all of the elements in the specified collection into this list. The new elements will appear in the list in the order that they are returned by the specified collection's iterator.
      Parameters:
      coll - collection containing elements to be added to this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      NullPointerException - if the specified collection is null
    • addAll

      public boolean addAll(int index, Collection<Float> coll)
      Inserts all of the elements in the specified collection into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the list in the order that they are returned by the specified collection's iterator.
      Parameters:
      index - index at which to insert the first element from the specified collection
      coll - collection containing elements to be inserted into this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      IndexOutOfBoundsException - if the index is invalid
      NullPointerException - if the specified collection is null
    • addArray

      public boolean addArray(float... elems)
      Adds all specified elements into this list.
      Parameters:
      elems - elements to be added to this list
      Returns:
      true if this list changed as a result of the call
    • addArray

      public boolean addArray(float[] elems, int offset, int length)
    • addArray

      public boolean addArray(int index, float[] elems, int offset, int length)
    • addArray

      public boolean addArray(int index, float... elems)
      Inserts the specified elements into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices).
      Parameters:
      index - index at which to insert the first element from the specified collection
      elems - elements to be inserted into this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      IndexOutOfBoundsException - if the index is invalid
    • addMult

      public boolean addMult(int len, float elem)
      Adds element multiple time to list.
      Parameters:
      elem - element to be added to this list
      Returns:
      true if this list changed as a result of the call
    • addMult

      public boolean addMult(int index, int len, float elem)
      Inserts element multiple time to list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices).
      Parameters:
      index - index at which to insert the first element from the specified collection
      elem - element to be inserted into this list
      Returns:
      true if this list changed as a result of the call
      Throws:
      IndexOutOfBoundsException - if the index is invalid
    • setAll

      public void setAll(int index, IFloatList list)
      Sets the specified elements.
      Parameters:
      index - index of first element to set
      list - list with elements to set
    • setAll

      public void setAll(int index, Collection<Float> coll)
      Sets the specified elements.
      Parameters:
      index - index of first element to set
      coll - collection with elements to set
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • setArray

      public void setArray(int index, float... elems)
      Sets the specified elements.
      Parameters:
      index - index of first element to set
      elems - array with elements to set
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • setArray

      public void setArray(int index, float[] elems, int offset, int length)
    • setMult

      public void setMult(int index, int len, float elem)
      Sets the element multiple times.
      Parameters:
      index - index of first element to set
      elem - element to set
    • putAll

      public void putAll(int index, IFloatList list)
      Set or add the specified elements.
      Parameters:
      index - index of first element to set or add
      list - list with elements to set or add
    • putAll

      public void putAll(int index, Collection<Float> coll)
      Set or add the specified elements. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.
      Parameters:
      index - index of first element to set or add
      coll - collection with elements to set or add
    • doPutAll

      protected void doPutAll(int index, IFloatListable list)
    • putArray

      public void putArray(int index, float... elems)
      Set or add the specified elements. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.
      Parameters:
      index - index of first element to set or add
      elems - array with elements to set or add
    • putMult

      public void putMult(int index, int len, float elem)
      Set or add the specified element multiple times. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.
      Parameters:
      index - index of first element to set or add
      len - element to set or add
    • initAll

      public void initAll(IFloatList list)
      Initializes the list so it will afterwards only contain the elements of the collection. The list will grow or shrink as needed.
      Parameters:
      list - list with elements
      Throws:
      IndexOutOfBoundsException - if the length is invalid
    • doInitAll

      protected void doInitAll(IFloatListable list)
    • initAll

      public void initAll(Collection<Float> coll)
      Initializes the list so it will afterwards only contain the elements of the collection. The list will grow or shrink as needed.
      Parameters:
      coll - collection with elements
      Throws:
      IndexOutOfBoundsException - if the length is invalid
    • asIFloatListable

      protected IFloatListable asIFloatListable(Collection<Float> coll)
      Return correct IFloatListable for passed collection.
    • initArray

      public void initArray(float... elems)
      Initializes the list so it will afterwards only contain the elements of the array. The list will grow or shrink as needed.
      Parameters:
      elems - array with elements
      Throws:
      IndexOutOfBoundsException - if the length is invalid
    • initMult

      public void initMult(int len, float elem)
      Initializes the list so it will afterwards have a size of len and contain only the element elem. The list will grow or shrink as needed.
      Parameters:
      len - length of list
      elem - element which the list will contain
      Throws:
      IndexOutOfBoundsException - if the length is invalid
    • replaceAll

      public void replaceAll(int index, int len, Collection<Float> coll)
      Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
      - addAll(index, list): replaceAll(index, 0, list)
      - setAll(index, list): replaceAll(index, list.size(), list)
      - putAll(index, list): replaceAll(index, -1, list)
      - initAll(list) : replaceAll(0, this.size(), list)
      - remove(index, list): replaceAll(index, list.size(), null)
      Parameters:
      index - index of first element to replace, use -1 for the position after the last element (this.size())
      len - number of elements to replace, use -1 for getting behavior of putAll()
      coll - collection with elements which replace the old elements, use null if elements should only be removed
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • replaceArray

      public void replaceArray(int index, int len, float... elems)
      Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
      - addAll(index, list): replaceAll(index, 0, list)
      - setAll(index, list): replaceAll(index, list.size(), list)
      - putAll(index, list): replaceAll(index, -1, list)
      - initAll(list) : replaceAll(0, this.size(), list)
      - remove(index, list): replaceAll(index, list.size(), null)
      Parameters:
      index - index of first element to replace, use -1 for the position after the last element (this.size())
      len - number of elements to replace, use -1 for getting behavior of putAll()
      elems - array with elements which replace the old elements, use null if elements should only be removed
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • replaceMult

      public void replaceMult(int index, int len, int numElems, float elem)
      Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
      - addAll(index, list): replaceAll(index, 0, list)
      - setAll(index, list): replaceAll(index, list.size(), list)
      - putAll(index, list): replaceAll(index, -1, list)
      - initAll(list) : replaceAll(0, this.size(), list)
      - remove(index, list): replaceAll(index, list.size(), null)
      Parameters:
      index - index of first element to replace, use -1 for the position after the last element (this.size())
      len - number of elements to replace, use -1 for getting behavior of putAll()
      numElems - number of time element has to be added
      elem - element to add
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • replaceAll

      public void replaceAll(int index, int len, IFloatList list)
      Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
      - addAll(index, list): replaceAll(index, 0, list)
      - setAll(index, list): replaceAll(index, list.size(), list)
      - putAll(index, list): replaceAll(index, -1, list)
      - initAll(list) : replaceAll(0, this.size(), list)
      - remove(index, list): replaceAll(index, list.size(), null)
      Parameters:
      index - index of first element to replace, use -1 for the position after the last element (this.size())
      len - number of elements to replace, use -1 for getting behavior of putAll()
      list - list with elements which replace the old elements, use null if elements should only be removed
      Throws:
      IndexOutOfBoundsException - if the range is invalid
    • replace

      protected void replace(int index, int len, IFloatListable list)
    • doReplace

      protected boolean doReplace(int index, int len, IFloatListable list)
    • fill

      public void fill(float elem)
    • copy

      public void copy(int srcIndex, int dstIndex, int len)
      Copy specified elements. Source and destination ranges may overlap. The size of the list does not change.
      Parameters:
      srcIndex - index of first source element to copy
      dstIndex - index of first destination element to copy
      len - number of elements to copy
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • move

      public void move(int srcIndex, int dstIndex, int len)
      Move specified elements. Source and destination ranges may overlap. The elements which are moved away are set to null, so the size of the list does not change.
      Parameters:
      srcIndex - index of first source element to move
      dstIndex - index of first destination element to move
      len - number of elements to move
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • drag

      public void drag(int srcIndex, int dstIndex, int len)
      Drag specified elements. Source and destination ranges may overlap. The size of the list does not change and it contains the same elements as before, but in changed order.
      Parameters:
      srcIndex - index of first source element to move
      dstIndex - index of first destination element to move
      len - number of elements to move
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • swap

      public void swap(int index1, int index2, int len)
      Swap the specified elements in the list.
      Parameters:
      index1 - index of first element in first range to swap
      index2 - index of first element in second range to swap
      len - number of elements to swap
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • reverse

      public void reverse()
      Reverses the order of all elements in the specified list.
    • reverse

      public void reverse(int index, int len)
      Reverses the order of the specified elements in the list.
      Parameters:
      index - index of first element to reverse
      len - number of elements to reverse
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • rotate

      public void rotate(int distance)
      Rotate specified elements in the list. The distance argument can be positive or negative: If it is positive, the elements are moved towards the end, if negative, the elements are moved toward the beginning, if distance is 0, the list is not changed.
      Parameters:
      distance - distance to move the elements
    • rotate

      public void rotate(int index, int len, int distance)
      Rotate specified elements in the list. The distance argument can be positive or negative: If it is positive, the elements are moved towards the end, if negative, the elements are moved toward the beginning, if distance is 0, the list is not changed.
      Parameters:
      index - index of first element to rotate
      len - number of elements to rotate
      distance - distance to move the elements
      Throws:
      IndexOutOfBoundsException - if the ranges are invalid
    • doRotate

      protected void doRotate(int index, int len, int distance)
      Internal method to rotate specified elements in the list. The distance argument can be positive or negative: If it is positive, the elements are moved towards the end, if negative, the elements are moved toward the beginning, if distance is 0, the list is not changed.
      Parameters:
      index - index of first element to rotate
      len - number of elements to rotate
      distance - distance to move the elements
    • sort

      public void sort()
      Sort elements in the list using the specified comparator.
      Parameters:
      comparator - comparator to use for sorting (null means the elements natural ordering should be used)
      See Also:
    • sort

      public abstract void sort(int index, int len)
      Sort specified elements in the list using the specified comparator.
      Parameters:
      index - index of first element to sort
      len - number of elements to sort
      comparator - comparator to use for sorting (null means the elements natural ordering should be used)
      Throws:
      IndexOutOfBoundsException - if the range is invalid
      See Also:
    • binarySearch

      public int binarySearch(float key)
      Searches the specified range for an object using the binary* search algorithm.

      Note that the method is defined to work with an arbitrary type <K>. This allows to search directly for a key field in the object without the need to construct an object containing the key:

      
        persons.binarySearch("john", new SearchByName());
      
        class SearchByName implements Comparator<Object> {
       	 public int compare(Object o1, Object o2) {
       	   String s1 = (o1 instanceof String) ? (String) o1 : ((Name) o1).getName();
       	   String s2 = (o2 instanceof String) ? (String) o2 : ((Name) o2).getName();
       	   return s1.compareTo(s2);
       	 }
        }
        
      Parameters:
      key - the value to be searched for
      comparator - the comparator by which the list is ordered. A null value indicates that the elements' natural ordering should be used.
      Returns:
      index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
      See Also:
    • binarySearch

      public abstract int binarySearch(int index, int len, float key)
      Searches the specified range for an object using the binary search algorithm.

      Note that the method is defined to work with an arbitrary type <K>. This allows to search directly for a key field in the object without the need to construct an object containing the key:

      
        persons.binarySearch("john", new SearchByName());
      
        class SearchByName implements Comparator<Object> {
       	 public int compare(Object o1, Object o2) {
       	   String s1 = (o1 instanceof String) ? (String) o1 : ((Name) o1).getName();
       	   String s2 = (o2 instanceof String) ? (String) o2 : ((Name) o2).getName();
       	   return s1.compareTo(s2);
       	 }
        }
        /
      Parameters:
      index - index of first element to search
      len - number of elements to search
      key - the value to be searched for
      comparator - the comparator by which the list is ordered. A null value indicates that the elements' natural ordering should be used.
      Returns:
      index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
      Throws:
      IndexOutOfBoundsException - if the range is invalid
      See Also:
    • checkIndex

      protected void checkIndex(int index)
      Check that specified index is valid for getting/setting elements.
      Parameters:
      index - index to check
      Throws:
      IndexOutOfBoundsException - if index is invalid
    • checkIndexAdd

      protected void checkIndexAdd(int index)
      Check that specified index is valid for adding elements.
      Parameters:
      index - index to check
      Throws:
      IndexOutOfBoundsException - if index is invalid
    • checkRange

      protected void checkRange(int index, int len)
      Check that specified range is valid.
      Parameters:
      index - start index of range to check
      len - number of elements in range to check
      Throws:
      IndexOutOfBoundsException - if index is invalid
    • checkLength

      protected void checkLength(int len)
      Check that specified length is valid (>= 0).
      Parameters:
      len - length to check
      Throws:
      IndexOutOfBoundsException - if length is invalid
    • checkLengths

      protected void checkLengths(int len1, int len2)
      Check that both specified lengths are valid (>= 0) and equal.
      Parameters:
      len1 - length to check
      len2 - length to check
      Throws:
      IndexOutOfBoundsException - if lengths are invalid
    • checkNonNull

      protected void checkNonNull(Object obj)
      Check that object is not null.
      Parameters:
      obj - object to check
      Throws:
      NullPointerException - if object is null