IFloatList

java.lang.Object
- org.magicwerk.brownies.collections.primitive.IFloatList

Type Parameters:
E - type of elements stored in the list

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:

FloatGapList
```
public abstract class IFloatList
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
GapList combines the strengths of both ArrayList and LinkedList. It is implemented to offer both efficient random access to elements by index (as ArrayList does) and at the same time efficient adding and removing elements to and from beginning and end (as LinkedList does). It also exploits the locality of reference often seen in applications to further improve performance, e.g. for iterating over the list.
Note that this implementation is not synchronized.

Version:

$Id: GapList.java 2098 2014-01-13 00:37:08Z origo $

Author:

Thomas Mauch

See Also:
List, ArrayList, LinkedList, Serialized Form

Constructor Summary

Constructors
Constructor and Description

IFloatList()

Constructors
Constructor and Description
`IFloatList()`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(float elem)`
`void`	`add(int index, float elem)`
`boolean`	`addAll(java.util.Collection<java.lang.Float> coll)` Adds all of the elements in the specified collection into this list.
`boolean`	`addAll(float... elems)` Adds all specified elements into this list.
`boolean`	`addAll(IFloatList list)` Adds all of the elements in the specified list into this list.
`boolean`	`addAll(int index, java.util.Collection<java.lang.Float> coll)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
`boolean`	`addAll(int index, float... elems)` Inserts the specified elements 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.
`void`	`addFirst(float elem)`
`boolean`	`addIfAbsent(float elem)` Add elements if it is not already contained in the list.
`void`	`addLast(float elem)`
`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`	`capacity()` Returns capacity of this GapList.
`void`	`clear()`
`java.lang.Object`	`clone()` Returns a shallow copy of this `GapList` instance (The elements themselves are not copied).
`boolean`	`contains(float elem)`
`boolean`	`containsAll(java.util.Collection<java.lang.Float> coll)`
`boolean`	`containsAny(java.util.Collection<java.lang.Float> coll)` Returns true if any of the elements of the specified collection is contained in the list.
`IFloatList`	`copy()` Returns a shallow copy of this `GapList` instance (the new list will contain the same elements as the source list, i.e. the elements themselves are not copied).
`static void`	`copy(IFloatList src, int srcIndex, IFloatList dst, int dstIndex, int len)` Copies elements from one GapList to another.
`void`	`copy(int srcIndex, int dstIndex, int len)` Copy specified elements.
`void`	`drag(int srcIndex, int dstIndex, int len)` Drag specified elements.
`float`	`element()`
`void`	`ensureCapacity(int minCapacity)` Increases the capacity of this `GapList` instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
`boolean`	`equals(java.lang.Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`fill(float elem)` Fill list.
`void`	`fill(int index, int len, float elem)` Fill specified elements.
`void`	`filter(Predicate<java.lang.Float> predicate)` Filter the list using the specified predicate.
`float`	`get(int index)`
`IFloatList`	`getAll(float elem)` Returns all elements in the list equal to the specified element.
`IFloatList`	`getAll(int index, int len)` Returns specified range of elements from list.
`float[]`	`getArray(int index, int len)` Returns specified range of elements from list.
`int`	`getCount(float elem)` Counts how many times the specified element is contained in the list.
`java.util.Set`	`getDistinct()` Returns distinct elements in the list.
`float`	`getFirst()`
`float`	`getLast()`
`int`	`hashCode()` Returns a hash code value for the object.
`int`	`indexOf(float elem)`
`void`	`init(int len, float elem)` Initializes the list so it will afterwards have a size of `len` and contain only the element `elem`.
`boolean`	`isEmpty()`
`int`	`lastIndexOf(float elem)`
`<R> IList<R>`	`mappedList(Mapper<java.lang.Float,R> mapper)` Create a new list by applying the specified mapper to all elements.
`static void`	`move(IFloatList src, int srcIndex, IFloatList dst, int dstIndex, int len)` Moves elements from one GapList to another.
`void`	`move(int srcIndex, int dstIndex, int len)` Move specified elements.
`boolean`	`offer(float elem)`
`boolean`	`offerFirst(float elem)`
`boolean`	`offerLast(float elem)`
`float`	`peek()`
`float`	`peekFirst()`
`float`	`peekLast()`
`float`	`poll()`
`float`	`pollFirst()`
`float`	`pollLast()`
`float`	`pop()`
`void`	`push(float elem)`
`float`	`remove()`
`float`	`remove(int index)`
`void`	`remove(int index, int len)` Remove specified range of elements from list.
`boolean`	`removeAll(java.util.Collection<java.lang.Float> coll)`
`IFloatList`	`removeAll(float elem)` Removes all equal elements.
`boolean`	`removeAll(IFloatList coll)`
`boolean`	`removeElem(float elem)`
`float`	`removeFirst()`
`boolean`	`removeFirstOccurrence(float elem)`
`float`	`removeLast()`
`boolean`	`removeLastOccurrence(float elem)`
`void`	`resize(int len, float elem)` Resizes the list so it will afterwards have a size of `len`.
`boolean`	`retainAll(java.util.Collection<java.lang.Float> coll)`
`boolean`	`retainAll(IFloatList coll)`
`void`	`reverse()` 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, java.util.Collection<java.lang.Float> coll)` Replaces the specified elements.
`void`	`setAll(int index, float... elems)` Replaces the specified elements.
`void`	`setAll(int index, IFloatList list)` Replaces the specified elements.
`abstract int`	`size()`
`void`	`sort()` 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.
`static void`	`swap(IFloatList src, int srcIndex, IFloatList dst, int dstIndex, int len)` Swaps elements from two GapLists.
`void`	`swap(int index1, int index2, int len)` Swap the specified elements in the list.
`float[]`	`toArray()`
`float[]`	`toArray(float[] array)`
`float[]`	`toArray(int index, int len)` Returns an array containing the specified elements in this list.
`java.lang.String`	`toString()` Returns a string representation of the object.
`abstract void`	`trimToSize()` Trims the capacity of this `GapList` instance to be the list's current size.
`abstract IFloatList`	`unmodifiableList()` Returns an unmodifiable view of this list.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - IFloatList
```
public IFloatList()
```
- Method Detail
  - copy
```
public IFloatList copy()
```
    Returns a shallow copy of this GapList instance (the new list will contain the same elements as the source list, i.e. the elements themselves are not copied). This method is identical to clone() except that the result is casted to GapList.
    
    Returns:
    a clone of this instance
    See Also:
    clone()
  - unmodifiableList
```
public abstract IFloatList unmodifiableList()
```
    Returns an unmodifiable view of this list. This method allows modules to provide users with "read-only" access to internal lists. Query operations on the returned list "read through" to the specified list, and attempts to modify the returned list, whether direct or via its iterator, result in an UnsupportedOperationException.
    
    Returns:
    an unmodifiable view of the specified list
  - clone
```
public java.lang.Object clone()
```
    Returns a shallow copy of this GapList instance (The elements themselves are not copied). The capacity of the list will be set to the number of elements, so after calling clone(), size and capacity are equal.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    a clone of this GapList instance
    See Also:
    Cloneable
  - clear
```
public void clear()
```
  - size
```
public abstract int size()
```
  - capacity
```
public abstract int capacity()
```
    Returns capacity of this GapList. Note that two GapLists 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 GapList
  - get
```
public float get(int index)
```
  - set
```
public float set(int index,
        float elem)
```
  - add
```
public boolean add(float elem)
```
  - add
```
public void add(int index,
       float elem)
```
  - remove
```
public float remove(int index)
```
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
    Increases the capacity of this GapList 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()
```
    Trims the capacity of this GapList instance to be the list's current size. An application can use this operation to minimize the storage of an GapList instance.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Description copied from class: java.lang.Object
    Indicates whether some other object is "equal to" this one.
    The equals method implements an equivalence relation on non-null object references:
    - It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    - It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    - It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    - It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    - For any non-null reference value x, x.equals(null) should return false.
    The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
    Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - the reference object with which to compare.
    
    Returns:
    true if this object is the same as the obj argument; false otherwise.
    See Also:
    Object.hashCode(), Hashtable
  - hashCode
```
public int hashCode()
```
    Description copied from class: java.lang.Object
    Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable.
    The general contract of hashCode is:
    - Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
    - If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
    - It is not required that if two objects are unequal according to the Object.equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.
    As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java^TM programming language.)
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a hash code value for this object.
    See Also:
    Object.equals(java.lang.Object), Hashtable
  - toString
```
public java.lang.String toString()
```
    Description copied from class: java.lang.Object
    Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
    The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
    getClass().getName() + '@' + Integer.toHexString(hashCode())
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of the object.
  - isEmpty
```
public boolean isEmpty()
```
  - getCount
```
public int getCount(float elem)
```
    Counts how many times the specified element is contained in the list.
    
    Parameters:
    elem - element to count
    
    Returns:
    count how many times the specified element is contained in the list
  - 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
  - getDistinct
```
public java.util.Set getDistinct()
```
    Returns distinct elements in the list.
    
    Returns:
    distinct elements in the list
  - mappedList
```
public <R> IList<R> mappedList(Mapper<java.lang.Float,R> mapper)
```
    Create a new list by applying the specified mapper to all elements.
    
    Parameters:
    mapper - mapper function
    
    Returns:
    created list
  - filter
```
public void filter(Predicate<java.lang.Float> predicate)
```
    Filter the list using the specified predicate. Only element which are allowed remain in the list, the others are removed
    
    Parameters:
    predicate - predicate used for filtering
  - indexOf
```
public int indexOf(float elem)
```
  - lastIndexOf
```
public int lastIndexOf(float elem)
```
  - removeElem
```
public boolean removeElem(float elem)
```
  - contains
```
public boolean contains(float elem)
```
  - addIfAbsent
```
public boolean addIfAbsent(float elem)
```
    Add elements if it is not already contained in the list.
    
    Parameters:
    elem - element to add
    
    Returns:
    true if element has been added, false if not
  - containsAny
```
public boolean containsAny(java.util.Collection<java.lang.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(java.util.Collection<java.lang.Float> coll)
```
  - removeAll
```
public boolean removeAll(java.util.Collection<java.lang.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(IFloatList coll)
```
    See Also:
    removeAll(Collection)
  - retainAll
```
public boolean retainAll(java.util.Collection<java.lang.Float> coll)
```
  - retainAll
```
public boolean retainAll(IFloatList coll)
```
    See Also:
    retainAll(Collection)
  - toArray
```
public float[] toArray()
```
  - 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 the specified elements
  - toArray
```
public float[] toArray(float[] array)
```
  - addAll
```
public boolean addAll(java.util.Collection<java.lang.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:
    
    java.lang.NullPointerException - if the specified collection is null
  - addAll
```
public boolean addAll(int index,
             java.util.Collection<java.lang.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:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
    
    java.lang.NullPointerException - if the specified collection is null
  - addAll
```
public boolean addAll(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
  - addAll
```
public boolean addAll(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:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
  - 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:
    
    java.lang.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:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
    
    java.lang.NullPointerException - if the specified collection is null
  - 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()
```
  - getLast
```
public float getLast()
```
  - 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)
```
  - move
```
public static void move(IFloatList src,
        int srcIndex,
        IFloatList dst,
        int dstIndex,
        int len)
```
    Moves elements from one GapList to another.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    src - source list
    srcIndex - index of first element in source list
    dst - destination list
    dstIndex - index of first element in source list
    len - number of elements to move
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - copy
```
public static void copy(IFloatList src,
        int srcIndex,
        IFloatList dst,
        int dstIndex,
        int len)
```
    Copies elements from one GapList to another.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    src - source list
    srcIndex - index of first element in source list
    dst - destination list
    dstIndex - index of first element in source list
    len - number of elements to copy
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - swap
```
public static void swap(IFloatList src,
        int srcIndex,
        IFloatList dst,
        int dstIndex,
        int len)
```
    Swaps elements from two GapLists.
    
    Type Parameters:
    E - type of elements stored in the list
    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
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - 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:
    GapList containing the specified range of elements from list
  - getArray
```
public float[] getArray(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:
    GapList containing the specified range of elements from list
  - setAll
```
public void setAll(int index,
          IFloatList list)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    list - list with elements to set
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - setAll
```
public void setAll(int index,
          java.util.Collection<java.lang.Float> coll)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    coll - collection with elements to set
  - setAll
```
public void setAll(int index,
          float... elems)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    elems - elements to set
    
    Throws:
    
    java.lang.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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - init
```
public void init(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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - 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 - length of list
    elem - element which will be used for extending the list
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - fill
```
public void fill(float elem)
```
    Fill list.
    
    Parameters:
    elem - element used for filling
  - fill
```
public void fill(int index,
        int len,
        float elem)
```
    Fill specified elements.
    
    Parameters:
    index - index of first element to fill
    len - number of elements to fill
    elem - element used for filling
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - 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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - 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:
    Arrays.sort(long[])
  - 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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
    See Also:
    Arrays.sort(long[])
  - binarySearch
```
public int binarySearch(float key)
```
    Searches the specified range for an object using the binary search algorithm.
    
    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:
    Arrays.binarySearch(long[], long)
  - binarySearch
```
public abstract int binarySearch(int index,
               int len,
               float key)
```
    Searches the specified range for an object using the binary search algorithm.
    
    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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
    See Also:
    Arrays.binarySearch(long[], long)

Class IFloatList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IFloatList

Method Detail

copy

unmodifiableList

clone

clear

size

capacity

get

set

add

add

remove

ensureCapacity

trimToSize

equals

hashCode

toString

isEmpty

getCount

getAll

getDistinct

mappedList

filter

indexOf

lastIndexOf

removeElem

contains

addIfAbsent

containsAny

containsAll

removeAll

removeAll

removeAll

retainAll

retainAll

toArray

toArray

toArray

addAll

addAll

addAll

addAll

addAll

addAll

peek

element

poll

remove

offer

getFirst

getLast

addFirst

addLast

removeFirst

removeLast

offerFirst

offerLast

peekFirst

peekLast

pollFirst

pollLast

pop

push

removeFirstOccurrence

removeLastOccurrence

move

copy

swap

getAll

getArray

setAll

setAll

setAll

remove