IDoubleList

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

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

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:

DoubleBigList, DoubleGapList
```
public abstract class IDoubleList
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
IDoubleList is an abstract class which offers all interfaces offered by both ArrayList and LinkedList. It also offers additional methods which are then available in all implementations of GapList and BigList.

Version:

$Id: IDoubleList.java 2529 2014-10-22 23:49:04Z origo $

Author:

Thomas Mauch

See Also:
List, Deque, ArrayList, LinkedList, Serialized Form

Constructor Summary

Constructors
Constructor and Description

IDoubleList()

Constructors
Constructor and Description
`IDoubleList()`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(double elem)`
`void`	`add(int index, double elem)`
`boolean`	`addAll(java.util.Collection<java.lang.Double> coll)` Adds all of the elements in the specified collection into this list.
`boolean`	`addAll(double... elems)` Adds all specified elements into this list.
`boolean`	`addAll(IDoubleList list)` Adds all of the elements in the specified list into this list.
`boolean`	`addAll(int index, java.util.Collection<java.lang.Double> coll)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
`boolean`	`addAll(int index, double... elems)` Inserts the specified elements into this list, starting at the specified position.
`boolean`	`addAll(int index, IDoubleList list)` Inserts all of the elements in the specified list into this list, starting at the specified position.
`void`	`addFirst(double elem)`
`boolean`	`addIfAbsent(double elem)` Add elements if it is not already contained in the list.
`void`	`addLast(double elem)`
`int`	`binarySearch(double key)` Searches the specified range for an object using the binary search algorithm.
`abstract int`	`binarySearch(int index, int len, double key)` Searches the specified range for an object using the binary search algorithm.
`abstract int`	`capacity()` Returns capacity of this list.
`void`	`clear()`
`java.lang.Object`	`clone()` Returns a shallow copy of this list instance.
`boolean`	`contains(double elem)`
`boolean`	`containsAll(java.util.Collection<java.lang.Double> coll)`
`boolean`	`containsAny(java.util.Collection<java.lang.Double> coll)` Returns true if any of the elements of the specified collection is contained in the list.
`IDoubleList`	`copy()` Returns a shallow copy of this list instance.
`static void`	`copy(IDoubleList src, int srcIndex, IDoubleList dst, int dstIndex, int len)` Copies elements from one list to another.
`void`	`copy(int srcIndex, int dstIndex, int len)` Copy specified elements.
`void`	`drag(int srcIndex, int dstIndex, int len)` Drag specified elements.
`double`	`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.
`IDoubleList`	`extract(int index, int len)` Removes specified range of elements from list and return them.
`void`	`fill(double elem)` Fill list.
`void`	`fill(int index, int len, double elem)` Fill specified elements.
`void`	`filter(Predicate<java.lang.Double> predicate)` Filter the list using the specified predicate.
`double`	`get(int index)`
`IDoubleList`	`getAll(double elem)` Returns all elements in the list equal to the specified element.
`IDoubleList`	`getAll(int index, int len)` Returns specified range of elements from list.
`double[]`	`getArray(int index, int len)` Returns specified range of elements from list as array.
`int`	`getCount(double elem)` Counts how many times the specified element is contained in the list.
`java.util.Set`	`getDistinct()` Returns distinct elements in the list.
`double`	`getFirst()`
`double`	`getLast()`
`int`	`hashCode()` Returns a hash code value for the object.
`int`	`indexOf(double elem)`
`void`	`init(int len, double elem)` Initializes the list so it will afterwards have a size of `len` and contain only the element `elem`.
`boolean`	`isEmpty()`
`int`	`lastIndexOf(double elem)`
`<R> IList<R>`	`mappedList(Mapper<java.lang.Double,R> mapper)` Create a new list by applying the specified mapper to all elements.
`void`	`merge(int index, java.util.Collection<java.lang.Double> coll)` Set or add the specified elements.
`static void`	`move(IDoubleList src, int srcIndex, IDoubleList dst, int dstIndex, int len)` Moves elements from one list to another.
`void`	`move(int srcIndex, int dstIndex, int len)` Move specified elements.
`boolean`	`offer(double elem)`
`boolean`	`offerFirst(double elem)`
`boolean`	`offerLast(double elem)`
`double`	`peek()`
`double`	`peekFirst()`
`double`	`peekLast()`
`double`	`poll()`
`double`	`pollFirst()`
`double`	`pollLast()`
`double`	`pop()`
`void`	`push(double elem)`
`double`	`remove()`
`double`	`remove(int index)`
`void`	`remove(int index, int len)` Remove specified range of elements from list.
`boolean`	`removeAll(java.util.Collection<java.lang.Double> coll)`
`IDoubleList`	`removeAll(double elem)` Removes all equal elements.
`boolean`	`removeAll(IDoubleList coll)`
`boolean`	`removeElem(double elem)`
`double`	`removeFirst()`
`boolean`	`removeFirstOccurrence(double elem)`
`double`	`removeLast()`
`boolean`	`removeLastOccurrence(double elem)`
`void`	`resize(int len, double elem)` Resizes the list so it will afterwards have a size of `len`.
`boolean`	`retainAll(java.util.Collection<java.lang.Double> coll)`
`boolean`	`retainAll(IDoubleList 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.
`double`	`set(int index, double elem)`
`void`	`setAll(int index, java.util.Collection<java.lang.Double> coll)` Replaces the specified elements.
`void`	`setAll(int index, double... elems)` Replaces the specified elements.
`void`	`setAll(int index, IDoubleList 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(IDoubleList src, int srcIndex, IDoubleList dst, int dstIndex, int len)` Swaps elements from two lists.
`void`	`swap(int index1, int index2, int len)` Swap the specified elements in the list.
`double[]`	`toArray()`
`double[]`	`toArray(double[] array)`
`double[]`	`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()` An application can use this operation to minimize the storage of an instance.
`abstract IDoubleList`	`unmodifiableList()` Returns an unmodifiable view of this list.

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

- Constructor Detail
  - IDoubleList
```
public IDoubleList()
```
- Method Detail
  - copy
```
public IDoubleList copy()
```
    Returns a shallow copy of this list 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 an IDoubleList.
    
    Returns:
    a clone of this instance
    See Also:
    clone()
  - unmodifiableList
```
public abstract IDoubleList 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 list instance. (The elements themselves are not copied).
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    a clone of this list instance
    See Also:
    Cloneable
  - clear
```
public void clear()
```
  - size
```
public abstract int size()
```
  - 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 double get(int index)
```
  - set
```
public double set(int index,
         double elem)
```
  - add
```
public boolean add(double elem)
```
  - add
```
public void add(int index,
       double elem)
```
  - remove
```
public double 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()
```
    An application can use this operation to minimize the storage of an 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(double 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 IDoubleList getAll(double 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.Double,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.Double> 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(double elem)
```
  - lastIndexOf
```
public int lastIndexOf(double elem)
```
  - removeElem
```
public boolean removeElem(double elem)
```
  - contains
```
public boolean contains(double elem)
```
  - addIfAbsent
```
public boolean addIfAbsent(double 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.Double> 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.Double> coll)
```
  - removeAll
```
public boolean removeAll(java.util.Collection<java.lang.Double> coll)
```
  - removeAll
```
public IDoubleList removeAll(double elem)
```
    Removes all equal elements.
    
    Parameters:
    elem - element
    
    Returns:
    removed equal elements (never null)
  - removeAll
```
public boolean removeAll(IDoubleList coll)
```
    See Also:
    removeAll(Collection)
  - retainAll
```
public boolean retainAll(java.util.Collection<java.lang.Double> coll)
```
  - retainAll
```
public boolean retainAll(IDoubleList coll)
```
    See Also:
    retainAll(Collection)
  - toArray
```
public double[] toArray()
```
  - toArray
```
public double[] 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 double[] toArray(double[] array)
```
  - addAll
```
public boolean addAll(java.util.Collection<java.lang.Double> 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.Double> 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(double... 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,
             double... 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(IDoubleList 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,
             IDoubleList 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 double peek()
```
  - element
```
public double element()
```
  - poll
```
public double poll()
```
  - remove
```
public double remove()
```
  - offer
```
public boolean offer(double elem)
```
  - getFirst
```
public double getFirst()
```
  - getLast
```
public double getLast()
```
  - addFirst
```
public void addFirst(double elem)
```
  - addLast
```
public void addLast(double elem)
```
  - removeFirst
```
public double removeFirst()
```
  - removeLast
```
public double removeLast()
```
  - offerFirst
```
public boolean offerFirst(double elem)
```
  - offerLast
```
public boolean offerLast(double elem)
```
  - peekFirst
```
public double peekFirst()
```
  - peekLast
```
public double peekLast()
```
  - pollFirst
```
public double pollFirst()
```
  - pollLast
```
public double pollLast()
```
  - pop
```
public double pop()
```
  - push
```
public void push(double elem)
```
  - removeFirstOccurrence
```
public boolean removeFirstOccurrence(double elem)
```
  - removeLastOccurrence
```
public boolean removeLastOccurrence(double elem)
```
  - move
```
public static void move(IDoubleList src,
        int srcIndex,
        IDoubleList dst,
        int dstIndex,
        int len)
```
    Moves elements from one list 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(IDoubleList src,
        int srcIndex,
        IDoubleList dst,
        int dstIndex,
        int len)
```
    Copies elements from one list 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(IDoubleList src,
        int srcIndex,
        IDoubleList dst,
        int dstIndex,
        int len)
```
    Swaps elements from two lists.
    
    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 IDoubleList 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 IDoubleList 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
  - getArray
```
public double[] getArray(int index,
                int len)
```
    Returns specified range of elements from list as array.
    
    Parameters:
    index - index of first element to retrieve
    len - number of elements to retrieve
    
    Returns:
    array containing the specified range of elements
  - setAll
```
public void setAll(int index,
          IDoubleList 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.Double> coll)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    coll - collection with elements to set
  - merge
```
public void merge(int index,
         java.util.Collection<java.lang.Double> coll)
```
    Set or add the specified elements.
    
    Parameters:
    index - index of first element to set or add
    coll - collection with elements to set or add
  - setAll
```
public void setAll(int index,
          double... 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,
        double 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,
          double 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(double elem)
```
    Fill list.
    
    Parameters:
    elem - element used for filling
  - fill
```
public void fill(int index,
        int len,
        double 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(double 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,
               double 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 IDoubleList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IDoubleList

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

extract

getArray

setAll

setAll

merge