IDoubleList

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

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 4520 2019-09-21 00:41:58Z 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

All Methods Static Methods Instance Methods Abstract Methods Concrete 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(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, IDoubleList list)` Inserts all of the elements in the specified list into this list, starting at the specified position.
`boolean`	`addArray(double... elems)` Adds all specified elements into this list.
`boolean`	`addArray(double[] elems, int offset, int length)`
`boolean`	`addArray(int index, double... elems)` Inserts the specified elements into this list, starting at the specified position.
`boolean`	`addArray(int index, double[] elems, int offset, int length)`
`void`	`addFirst(double elem)`
`boolean`	`addIfAbsent(double elem)` Add elements if it is not already contained in the list.
`void`	`addLast(double elem)`
`boolean`	`addMult(int len, double elem)` Adds element multiple time to list.
`boolean`	`addMult(int index, int len, double elem)` Inserts element multiple time to list, starting at the specified position.
`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.
`boolean`	`containsIf(java.util.function.Predicate<java.lang.Double> predicate)` Determines whether the list contains a matching element.
`IDoubleList`	`copy()` Returns a shallow copy of this list instance.
`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)`
`IDoubleList`	`extract(int index, int len)` Removes specified range of elements from list and return them.
`IDoubleList`	`extractIf(java.util.function.Predicate<java.lang.Double> predicate)` Removes and returns all elements in the list which match the predicate.
`void`	`fill(double elem)` Fill list.
`void`	`filter(java.util.function.Predicate<java.lang.Double> predicate)` Filter the list using the specified predicate.
`IDoubleList`	`filteredList(java.util.function.Predicate<java.lang.Double> predicate)` Create a new list by applying the specified filter to all elements.
`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.
`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()`
`IDoubleList`	`getIf(java.util.function.Predicate predicate)` Returns all elements in the list which match the predicate.
`double`	`getLast()`
`double`	`getSingle()` Returns the only element stored in the list.
`double`	`getSingleOrEmpty()` Returns the only element stored in the list or null if the list is empty.
`int`	`hashCode()`
`int`	`indexOf(double elem)`
`int`	`indexOf(double 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`	`indexOfIf(java.util.function.Predicate<java.lang.Double> predicate)` Returns the index of the first element which matches the specified element in this list.
`void`	`initAll(java.util.Collection<java.lang.Double> coll)` Initializes the list so it will afterwards only contain the elements of the collection.
`void`	`initAll(IDoubleList list)` Initializes the list so it will afterwards only contain the elements of the collection.
`void`	`initArray(double... elems)` Initializes the list so it will afterwards only contain the elements of the array.
`void`	`initMult(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)`
`int`	`lastIndexOf(double elem, 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>`	`mappedList(java.util.function.Function<java.lang.Double,R> func)` Create a new list by applying the specified mapping function to all elements.
`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`	`put(int index, double elem)` Sets or adds the element.
`void`	`putAll(int index, java.util.Collection<java.lang.Double> coll)` Set or add the specified elements.
`void`	`putAll(int index, IDoubleList list)` Set or add the specified elements.
`void`	`putArray(int index, double... elems)` Set or add the specified elements.
`void`	`putMult(int index, int len, double elem)` Set or add the specified element multiple times.
`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)`
`boolean`	`removeIf(java.util.function.Predicate<java.lang.Double> predicate)` Removes all elements in the list which match the predicate.
`double`	`removeLast()`
`boolean`	`removeLastOccurrence(double elem)`
`void`	`replaceAll(int index, int len, java.util.Collection<java.lang.Double> coll)` Replaces the specified range with new elements.
`void`	`replaceAll(int index, int len, IDoubleList list)` Replaces the specified range with new elements.
`void`	`replaceArray(int index, int len, double... elems)` Replaces the specified range with new elements.
`void`	`replaceMult(int index, int len, int numElems, double elem)` Replaces the specified range with new elements.
`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)`
`boolean`	`retainIf(java.util.function.Predicate<java.lang.Double> predicate)` Retains all elements in the list which match the predicate.
`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)` Sets the specified elements.
`void`	`setAll(int index, IDoubleList list)` Sets the specified elements.
`void`	`setArray(int index, double... elems)` Sets the specified elements.
`void`	`setArray(int index, double[] elems, int offset, int length)`
`void`	`setMult(int index, int len, double elem)` Sets the element multiple times.
`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.
`void`	`swap(int index1, int index2, int len)` Swap the specified elements in the list.
`double[]`	`toArray()`
`double[]`	`toArray(java.lang.Class clazz)` Returns an array containing the elements in this list.
`double[]`	`toArray(java.lang.Class clazz, int index, int len)` Returns an array containing the specified elements in this list.
`double[]`	`toArray(double[] array)`
`double[]`	`toArray(double[] array, int index, int len)` Returns an array containing the specified elements in this list.
`double[]`	`toArray(int index, int len)` Returns an array containing the specified elements in this list.
`java.lang.String`	`toString()`
`static void`	`transferCopy(IDoubleList src, int srcIndex, int srcLen, IDoubleList dst, int dstIndex, int dstLen)` Copies elements from one list to another.
`static void`	`transferMove(IDoubleList src, int srcIndex, int srcLen, IDoubleList dst, int dstIndex, int dstLen)` Moves elements from one list to another by setting it to null in the source list.
`static void`	`transferRemove(IDoubleList src, int srcIndex, int srcLen, IDoubleList dst, int dstIndex, int dstLen)` Moves elements from one list to another by removing it from the source list.
`static void`	`transferSwap(IDoubleList src, int srcIndex, IDoubleList dst, int dstIndex, int len)` Swaps elements from two lists.
`void`	`transform(java.util.function.UnaryOperator<java.lang.Double> op)` Change the list by applying the specified operator to all elements.
`IDoubleList`	`transformedList(java.util.function.UnaryOperator<java.lang.Double> op)` Create a new list by applying the specified transforming operator to all elements.
`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
  - clear
```
public void clear()
```
  - 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
  - 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)
```
  - put
```
public double put(int index,
                  double 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
  - 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)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.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
  - getSingle
```
public double getSingle()
```
    Returns the only element stored in the list. If the list's size is not 1, a NoSuchElementException is thrown.
    
    Returns:
    
    only element stored in the list
  - getSingleOrEmpty
```
public double getSingleOrEmpty()
```
    Returns the only element stored in the list or null if the list is empty. If the list's size is greater than 1, a NoSuchElementException is thrown.
    
    Returns:
    
    only element stored 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
  - getIf
```
public IDoubleList getIf(java.util.function.Predicate predicate)
```
    Returns all elements in the list which match the predicate.
    
    Parameters:
    
    predicate - predicate
    
    Returns:
    
    all elements in the list which match the predicate
  - removeIf
```
public boolean removeIf(java.util.function.Predicate<java.lang.Double> 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 any elements were removed
  - retainIf
```
public boolean retainIf(java.util.function.Predicate<java.lang.Double> 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 any elements were removed
  - extractIf
```
public IDoubleList extractIf(java.util.function.Predicate<java.lang.Double> 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
  - getDistinct
```
public java.util.Set getDistinct()
```
    Returns distinct elements in the list.
    
    Returns:
    
    distinct elements in the list
  - mappedList
```
public <R> IList<R> mappedList(java.util.function.Function<java.lang.Double,R> func)
```
    Create a new list by applying the specified mapping function to all elements.
    
    Parameters:
    
    func - mapping function
    
    Returns:
    
    created list
  - transformedList
```
public IDoubleList transformedList(java.util.function.UnaryOperator<java.lang.Double> 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(java.util.function.UnaryOperator<java.lang.Double> op)
```
    Change the list by applying the specified operator to all elements.
    
    Parameters:
    
    op - transforming operator
  - filteredList
```
public IDoubleList filteredList(java.util.function.Predicate<java.lang.Double> 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
  - filter
```
public void filter(java.util.function.Predicate<java.lang.Double> predicate)
```
    Filter the list using the specified predicate. Only elements which are allowed by the predicate remain in the list, the others are removed
    
    Parameters:
    
    predicate - predicate used for filtering
  - indexOf
```
public int indexOf(double elem)
```
  - indexOfIf
```
public int indexOfIf(java.util.function.Predicate<java.lang.Double> predicate)
```
    Returns the index of the first element which matches the specified element in this list.
    
    Parameters:
    
    predicate - predicate used to search element
    
    Returns:
    
    the index of the first element which matches the specified element, or -1 if this list does not contain the element
    
    See Also:
    
    #indexOf(Object)
  - lastIndexOf
```
public int lastIndexOf(double elem)
```
  - indexOf
```
public int indexOf(double 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:
    
    #indexOf(Object)
  - lastIndexOf
```
public int lastIndexOf(double 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:
    
    #lastIndexOf(Object)
  - removeElem
```
public boolean removeElem(double elem)
```
  - contains
```
public boolean contains(double elem)
```
  - containsIf
```
public boolean containsIf(java.util.function.Predicate<java.lang.Double> 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(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 IDoubleList removeAll(double elem)
```
    Removes all equal elements.
    
    Parameters:
    
    elem - element
    
    Returns:
    
    removed equal elements (never null)
  - removeAll
```
public boolean removeAll(java.util.Collection<java.lang.Double> coll)
```
  - 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(double[] array)
```
  - toArray
```
public double[] toArray(java.lang.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 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 containing the specified elements
    
    See Also:
    
    List.toArray()
  - toArray
```
public double[] toArray(double[] 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:
    
    List.toArray(Object[])
  - toArray
```
public double[] toArray(java.lang.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
  - 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)
```
  - transferCopy
```
public static void transferCopy(IDoubleList src,
                                int srcIndex,
                                int srcLen,
                                IDoubleList 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:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - transferMove
```
public static void transferMove(IDoubleList src,
                                int srcIndex,
                                int srcLen,
                                IDoubleList 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:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - transferRemove
```
public static void transferRemove(IDoubleList src,
                                  int srcIndex,
                                  int srcLen,
                                  IDoubleList 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:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - transferSwap
```
public static void transferSwap(IDoubleList src,
                                int srcIndex,
                                IDoubleList 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:
    
    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
  - 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
  - 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
  - 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
  - addArray
```
public boolean addArray(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
  - addArray
```
public boolean addArray(double[] elems,
                        int offset,
                        int length)
```
  - addArray
```
public boolean addArray(int index,
                        double[] elems,
                        int offset,
                        int length)
```
  - addArray
```
public boolean addArray(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
  - addMult
```
public boolean addMult(int len,
                       double 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,
                       double 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:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
  - setAll
```
public void setAll(int index,
                   IDoubleList list)
```
    Sets 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)
```
    Sets the specified elements.
    
    Parameters:
    
    index - index of first element to set
    
    coll - collection with elements to set
  - setArray
```
public void setArray(int index,
                     double... elems)
```
    Sets the specified elements.
    
    Parameters:
    
    index - index of first element to set
    
    elems - array with elements to set
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - setArray
```
public void setArray(int index,
                     double[] elems,
                     int offset,
                     int length)
```
  - setMult
```
public void setMult(int index,
                    int len,
                    double elem)
```
    Sets the element multiple times.
    
    Parameters:
    
    index - index of first element to set
    
    elem - element to set
  - putAll
```
public void putAll(int index,
                   IDoubleList 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,
                   java.util.Collection<java.lang.Double> 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
  - putArray
```
public void putArray(int index,
                     double... 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,
                    double 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(IDoubleList 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:
    
    java.lang.IndexOutOfBoundsException - if the length is invalid
  - initAll
```
public void initAll(java.util.Collection<java.lang.Double> 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:
    
    java.lang.IndexOutOfBoundsException - if the length is invalid
  - initArray
```
public void initArray(double... 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:
    
    java.lang.IndexOutOfBoundsException - if the length is invalid
  - initMult
```
public void initMult(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 length is invalid
  - replaceAll
```
public void replaceAll(int index,
                       int len,
                       java.util.Collection<java.lang.Double> 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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - replaceArray
```
public void replaceArray(int index,
                         int len,
                         double... 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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - replaceMult
```
public void replaceMult(int index,
                        int len,
                        int numElems,
                        double 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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - replaceAll
```
public void replaceAll(int index,
                       int len,
                       IDoubleList 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:
    
    java.lang.IndexOutOfBoundsException - if the range is invalid
  - fill
```
public void fill(double elem)
```
    Fill list.
    
    Parameters:
    
    elem - element used for filling
  - 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
  - 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
  - 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
  - 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(int[])
  - 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(int[])
  - 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

resize

size

capacity

get

set

put

add

add

remove

ensureCapacity

trimToSize

equals

hashCode

toString

isEmpty

getCount

getSingle

getSingleOrEmpty

getAll

getIf

removeIf

retainIf

extractIf

getDistinct

mappedList

transformedList

transform

filteredList

filter

indexOf

indexOfIf

lastIndexOf

indexOf

lastIndexOf

removeElem

contains

containsIf

addIfAbsent

containsAny

containsAll

removeAll

removeAll

removeAll

retainAll

retainAll

toArray

toArray

toArray

toArray

toArray

toArray

peek

element

poll

remove

offer

getFirst

getLast

addFirst

addLast

removeFirst

removeLast

offerFirst

offerLast

peekFirst

peekLast

pollFirst

pollLast

pop