java.lang.Object
- org.eclipse.collections.impl.collection.mutable.primitive.AbstractSynchronizedDoubleCollection
- - org.eclipse.collections.impl.list.mutable.primitive.SynchronizedDoubleList

All Implemented Interfaces:

java.io.Serializable, MutableDoubleCollection, DoubleIterable, DoubleList, MutableDoubleList, OrderedDoubleIterable, ReversibleDoubleIterable, PrimitiveIterable
```
public class SynchronizedDoubleList
extends AbstractSynchronizedDoubleCollection
implements MutableDoubleList
```
A synchronized view of a MutableDoubleList. It is imperative that the user manually synchronize on the on the collection when iterating over it using an iterator or stream.
This file was automatically generated from template file synchronizedPrimitiveList.stg.

Since:

3.1.

See Also:

MutableDoubleList.asSynchronized(), MutableList.asSynchronized(), Serialized Form

Field Summary

Fields
Modifier and Type Field Description

private static long serialVersionUID

Constructor Summary

Constructors
Constructor	Description
`SynchronizedDoubleList(MutableDoubleList list)`
`SynchronizedDoubleList(MutableDoubleList list, java.lang.Object newLock)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`addAllAtIndex(int index, double... source)`
`boolean`	`addAllAtIndex(int index, DoubleIterable source)`
`void`	`addAtIndex(int index, double element)`
`LazyDoubleIterable`	`asLazy()`	Returns a LazyDoubleIterable adapter wrapping the source DoubleIterable.
`LazyDoubleIterable`	`asReversed()`
`MutableDoubleList`	`asSynchronized()`
`MutableDoubleList`	`asUnmodifiable()`
`int`	`binarySearch(double value)`
`MutableList<java.lang.Double>`	`boxed()`
`<V> MutableList<V>`	`collect(DoubleToObjectFunction<? extends V> function)`	Returns a new collection with the results of applying the specified function on each element of the source collection.
`<V> MutableList<V>`	`collectWithIndex(DoubleIntToObjectFunction<? extends V> function)`	Returns a new MutableList using results obtained by applying the specified function to each element and its corresponding index.
`<V,R extends java.util.Collection<V>> R`	`collectWithIndex(DoubleIntToObjectFunction<? extends V> function, R target)`	Adds elements to the target Collection using results obtained by applying the specified function to each element and its corresponding index.
`MutableDoubleList`	`distinct()`
`double`	`dotProduct(DoubleList list)`
`boolean`	`equals(java.lang.Object otherList)`	Follows the same general contract as `List.equals(Object)`.
`void`	`forEachInBoth(DoubleList other, DoubleDoubleProcedure procedure)`	This method iterates over two CharList instances of the same size together using the specified CharCharProcedure.
`void`	`forEachWithIndex(DoubleIntProcedure procedure)`
`double`	`get(int index)`
`double`	`getFirst()`
`double`	`getLast()`
`private MutableDoubleList`	`getMutableDoubleList()`
`int`	`hashCode()`	Follows the same general contract as `List.hashCode()`.
`int`	`indexOf(double value)`
`<T> T`	`injectIntoWithIndex(T injectedValue, ObjectDoubleIntToObjectFunction<? super T,? extends T> function)`
`int`	`lastIndexOf(double value)`
`MutableDoubleList`	`newEmpty()`	Creates a new empty mutable version of the same List type.
`MutableDoubleList`	`reject(DoublePredicate predicate)`	Returns a new DoubleIterable with all of the elements in the DoubleIterable that return false for the specified predicate.
`MutableDoubleList`	`rejectWithIndex(DoubleIntPredicate predicate)`	Returns a new MutableDoubleList excluding all elements with corresponding indexes matching the specified predicate.
`<R extends MutableDoubleCollection> R`	`rejectWithIndex(DoubleIntPredicate predicate, R target)`	Returns a new MutableDoubleCollection excluding all elements with corresponding indexes matching the specified predicate.
`double`	`removeAtIndex(int index)`
`MutableDoubleList`	`reverseThis()`
`MutableDoubleList`	`select(DoublePredicate predicate)`	Returns a new DoubleIterable with all of the elements in the DoubleIterable that return true for the specified predicate.
`MutableDoubleList`	`selectWithIndex(DoubleIntPredicate predicate)`	Returns a new MutableDoubleList including all elements with corresponding indexes matching the specified predicate.
`<R extends MutableDoubleCollection> R`	`selectWithIndex(DoubleIntPredicate predicate, R target)`	Returns a new MutableDoubleCollection including all elements with corresponding indexes matching the specified predicate.
`double`	`set(int index, double element)`
`MutableDoubleList`	`shuffleThis()`	Randomly permutes this list mutating its contents and returns the same list (this).
`MutableDoubleList`	`shuffleThis(java.util.Random rnd)`	Randomly permutes this list mutating its contents and returns the same list (this).
`MutableDoubleList`	`sortThis()`	Sorts this list mutating its contents and returns the same mutable list (this).
`MutableDoubleList`	`sortThis(DoubleComparator comparator)`	Sorts the internal data structure of this list and returns the list itself as a convenience.
`<T> MutableDoubleList`	`sortThisBy(DoubleToObjectFunction<T> function)`	Sorts the internal data structure of this list based on the natural order of the key returned by `function`.
`<T> MutableDoubleList`	`sortThisBy(DoubleToObjectFunction<T> function, java.util.Comparator<? super T> comparator)`	Sorts the internal data structure of this list based on the key returned by `function` using the provided `comparator`.
`java.util.Spliterator.OfDouble`	`spliterator()`	This function needs to be synchronized manually
`MutableDoubleList`	`subList(int fromIndex, int toIndex)`
`ImmutableDoubleList`	`toImmutable()`	Returns an immutable copy of this list.
`MutableDoubleList`	`toReversed()`
`MutableDoubleStack`	`toStack()`	Converts the collection to a DoubleStack.
`SynchronizedDoubleList`	`with(double element)`
`SynchronizedDoubleList`	`withAll(DoubleIterable elements)`
`SynchronizedDoubleList`	`without(double element)`
`SynchronizedDoubleList`	`withoutAll(DoubleIterable elements)`
`<T> MutableList<DoubleObjectPair<T>>`	`zip(java.lang.Iterable<T> iterable)`	Returns a `MutableList` formed from this `MutableDoubleList` and a `ListIterable` by combining corresponding elements in pairs.
`MutableList<DoubleDoublePair>`	`zipDouble(DoubleIterable iterable)`	Returns a `MutableList` formed from this `MutableDoubleList` and another `DoubleList` by combining corresponding elements in pairs.

Methods inherited from class org.eclipse.collections.impl.collection.mutable.primitive.AbstractSynchronizedDoubleCollection
add, addAll, addAll, allSatisfy, anySatisfy, appendString, appendString, appendString, average, chunk, clear, contains, containsAll, containsAll, containsAny, containsAny, containsNone, containsNone, count, detectIfNone, doubleIterator, each, getDoubleCollection, getLock, injectInto, isEmpty, makeString, makeString, makeString, max, maxIfEmpty, median, min, minIfEmpty, noneSatisfy, notEmpty, reduce, reduceIfEmpty, remove, removeAll, removeAll, removeIf, retainAll, retainAll, size, sum, toArray, toArray, toBag, toList, toSet, toSortedArray, toSortedList, toString

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

Methods inherited from interface org.eclipse.collections.api.DoubleIterable
allSatisfy, anySatisfy, average, averageIfEmpty, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, contains, containsAll, containsAll, containsAny, containsAny, containsNone, containsNone, count, detectIfNone, each, flatCollect, forEach, injectInto, injectIntoBoolean, injectIntoByte, injectIntoChar, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, injectIntoShort, max, maxIfEmpty, median, medianIfEmpty, min, minIfEmpty, noneSatisfy, reduce, reduceIfEmpty, reject, select, sum, summaryStatistics, toArray, toArray, toBag, toList, toSet, toSortedArray, toSortedList, toSortedList, toSortedListBy, toSortedListBy

Methods inherited from interface org.eclipse.collections.api.list.primitive.DoubleList
primitiveParallelStream, primitiveStream

Methods inherited from interface org.eclipse.collections.api.collection.primitive.MutableDoubleCollection
add, addAll, addAll, clear, doubleIterator, remove, removeAll, removeAll, removeIf, retainAll, retainAll

Methods inherited from interface org.eclipse.collections.api.list.primitive.MutableDoubleList
swap, tap

Methods inherited from interface org.eclipse.collections.api.PrimitiveIterable
appendString, appendString, appendString, isEmpty, makeString, makeString, makeString, notEmpty, size, toString

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SynchronizedDoubleList
```
public SynchronizedDoubleList(MutableDoubleList list)
```
  - SynchronizedDoubleList
```
public SynchronizedDoubleList(MutableDoubleList list,
                              java.lang.Object newLock)
```
- Method Detail
  - getMutableDoubleList
```
private MutableDoubleList getMutableDoubleList()
```
  - get
```
public double get(int index)
```
    Specified by:
    
    get in interface DoubleList
  - getFirst
```
public double getFirst()
```
    Specified by:
    
    getFirst in interface OrderedDoubleIterable
  - getLast
```
public double getLast()
```
    Specified by:
    
    getLast in interface ReversibleDoubleIterable
  - indexOf
```
public int indexOf(double value)
```
    Specified by:
    
    indexOf in interface OrderedDoubleIterable
  - lastIndexOf
```
public int lastIndexOf(double value)
```
    Specified by:
    
    lastIndexOf in interface DoubleList
  - addAtIndex
```
public void addAtIndex(int index,
                       double element)
```
    Specified by:
    
    addAtIndex in interface MutableDoubleList
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             double... source)
```
    Specified by:
    
    addAllAtIndex in interface MutableDoubleList
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             DoubleIterable source)
```
    Specified by:
    
    addAllAtIndex in interface MutableDoubleList
  - removeAtIndex
```
public double removeAtIndex(int index)
```
    Specified by:
    
    removeAtIndex in interface MutableDoubleList
  - set
```
public double set(int index,
                  double element)
```
    Specified by:
    
    set in interface MutableDoubleList
  - with
```
public SynchronizedDoubleList with(double element)
```
    Specified by:
    
    with in interface MutableDoubleCollection
    
    Specified by:
    
    with in interface MutableDoubleList
    
    Overrides:
    
    with in class AbstractSynchronizedDoubleCollection
  - without
```
public SynchronizedDoubleList without(double element)
```
    Specified by:
    
    without in interface MutableDoubleCollection
    
    Specified by:
    
    without in interface MutableDoubleList
    
    Overrides:
    
    without in class AbstractSynchronizedDoubleCollection
  - withAll
```
public SynchronizedDoubleList withAll(DoubleIterable elements)
```
    Specified by:
    
    withAll in interface MutableDoubleCollection
    
    Specified by:
    
    withAll in interface MutableDoubleList
    
    Overrides:
    
    withAll in class AbstractSynchronizedDoubleCollection
  - withoutAll
```
public SynchronizedDoubleList withoutAll(DoubleIterable elements)
```
    Specified by:
    
    withoutAll in interface MutableDoubleCollection
    
    Specified by:
    
    withoutAll in interface MutableDoubleList
    
    Overrides:
    
    withoutAll in class AbstractSynchronizedDoubleCollection
  - select
```
public MutableDoubleList select(DoublePredicate predicate)
```
    Description copied from interface: DoubleIterable
    
    Returns a new DoubleIterable with all of the elements in the DoubleIterable that return true for the specified predicate.
    
    Specified by:
    
    select in interface DoubleIterable
    
    Specified by:
    
    select in interface DoubleList
    
    Specified by:
    
    select in interface MutableDoubleCollection
    
    Specified by:
    
    select in interface MutableDoubleList
    
    Specified by:
    
    select in interface OrderedDoubleIterable
    
    Specified by:
    
    select in interface ReversibleDoubleIterable
    
    Overrides:
    
    select in class AbstractSynchronizedDoubleCollection
  - boxed
```
public MutableList<java.lang.Double> boxed()
```
    Specified by:
    
    boxed in interface MutableDoubleList
  - reject
```
public MutableDoubleList reject(DoublePredicate predicate)
```
    Description copied from interface: DoubleIterable
    
    Returns a new DoubleIterable with all of the elements in the DoubleIterable that return false for the specified predicate.
    
    Specified by:
    
    reject in interface DoubleIterable
    
    Specified by:
    
    reject in interface DoubleList
    
    Specified by:
    
    reject in interface MutableDoubleCollection
    
    Specified by:
    
    reject in interface MutableDoubleList
    
    Specified by:
    
    reject in interface OrderedDoubleIterable
    
    Specified by:
    
    reject in interface ReversibleDoubleIterable
    
    Overrides:
    
    reject in class AbstractSynchronizedDoubleCollection
  - collect
```
public <V> MutableList<V> collect(DoubleToObjectFunction<? extends V> function)
```
    Description copied from interface: DoubleIterable
    
    Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    
    Specified by:
    
    collect in interface DoubleIterable
    
    Specified by:
    
    collect in interface DoubleList
    
    Specified by:
    
    collect in interface MutableDoubleCollection
    
    Specified by:
    
    collect in interface MutableDoubleList
    
    Specified by:
    
    collect in interface OrderedDoubleIterable
    
    Specified by:
    
    collect in interface ReversibleDoubleIterable
    
    Overrides:
    
    collect in class AbstractSynchronizedDoubleCollection
  - sortThis
```
public MutableDoubleList sortThis()
```
    Description copied from interface: MutableDoubleList
    
    Sorts this list mutating its contents and returns the same mutable list (this).
    
    Specified by:
    
    sortThis in interface MutableDoubleList
  - sortThis
```
public MutableDoubleList sortThis(DoubleComparator comparator)
```
    Description copied from interface: MutableDoubleList
    
    Sorts the internal data structure of this list and returns the list itself as a convenience.
    
    Specified by:
    
    sortThis in interface MutableDoubleList
  - sortThisBy
```
public <T> MutableDoubleList sortThisBy(DoubleToObjectFunction<T> function)
```
    Description copied from interface: MutableDoubleList
    
    Sorts the internal data structure of this list based on the natural order of the key returned by function.
    
    Specified by:
    
    sortThisBy in interface MutableDoubleList
  - sortThisBy
```
public <T> MutableDoubleList sortThisBy(DoubleToObjectFunction<T> function,
                                        java.util.Comparator<? super T> comparator)
```
    Description copied from interface: MutableDoubleList
    
    Sorts the internal data structure of this list based on the key returned by function using the provided comparator.
    
    Specified by:
    
    sortThisBy in interface MutableDoubleList
  - shuffleThis
```
public MutableDoubleList shuffleThis()
```
    Description copied from interface: MutableDoubleList
    
    Randomly permutes this list mutating its contents and returns the same list (this). Uses java.util.Random as the source of randomness.
    
    Specified by:
    
    shuffleThis in interface MutableDoubleList
  - shuffleThis
```
public MutableDoubleList shuffleThis(java.util.Random rnd)
```
    Description copied from interface: MutableDoubleList
    
    Randomly permutes this list mutating its contents and returns the same list (this). Implements the Fisher-Yates shuffle algorithm using the provided source of randomness.
    
    Specified by:
    
    shuffleThis in interface MutableDoubleList
  - binarySearch
```
public int binarySearch(double value)
```
    Specified by:
    
    binarySearch in interface DoubleList
  - dotProduct
```
public double dotProduct(DoubleList list)
```
    Specified by:
    
    dotProduct in interface DoubleList
  - equals
```
public boolean equals(java.lang.Object otherList)
```
    Description copied from interface: DoubleList
    
    Follows the same general contract as List.equals(Object).
    
    Specified by:
    
    equals in interface DoubleList
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: DoubleList
    
    Follows the same general contract as List.hashCode().
    
    Specified by:
    
    hashCode in interface DoubleList
    
    Overrides:
    
    hashCode in class java.lang.Object
  - asLazy
```
public LazyDoubleIterable asLazy()
```
    Description copied from interface: DoubleIterable
    
    Returns a LazyDoubleIterable adapter wrapping the source DoubleIterable.
    
    Specified by:
    
    asLazy in interface DoubleIterable
    
    Overrides:
    
    asLazy in class AbstractSynchronizedDoubleCollection
  - asUnmodifiable
```
public MutableDoubleList asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableDoubleCollection
    
    Specified by:
    
    asUnmodifiable in interface MutableDoubleList
    
    Overrides:
    
    asUnmodifiable in class AbstractSynchronizedDoubleCollection
  - asSynchronized
```
public MutableDoubleList asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableDoubleCollection
    
    Specified by:
    
    asSynchronized in interface MutableDoubleList
    
    Overrides:
    
    asSynchronized in class AbstractSynchronizedDoubleCollection
  - toImmutable
```
public ImmutableDoubleList toImmutable()
```
    Description copied from interface: MutableDoubleList
    
    Returns an immutable copy of this list.
    
    Specified by:
    
    toImmutable in interface DoubleList
    
    Specified by:
    
    toImmutable in interface MutableDoubleCollection
    
    Specified by:
    
    toImmutable in interface MutableDoubleList
    
    Overrides:
    
    toImmutable in class AbstractSynchronizedDoubleCollection
  - newEmpty
```
public MutableDoubleList newEmpty()
```
    Description copied from interface: MutableDoubleList
    
    Creates a new empty mutable version of the same List type.
    
    Specified by:
    
    newEmpty in interface MutableDoubleCollection
    
    Specified by:
    
    newEmpty in interface MutableDoubleList
    
    Since:
    
    9.2.
  - reverseThis
```
public MutableDoubleList reverseThis()
```
    Specified by:
    
    reverseThis in interface MutableDoubleList
  - toReversed
```
public MutableDoubleList toReversed()
```
    Specified by:
    
    toReversed in interface DoubleList
    
    Specified by:
    
    toReversed in interface MutableDoubleList
    
    Specified by:
    
    toReversed in interface ReversibleDoubleIterable
  - asReversed
```
public LazyDoubleIterable asReversed()
```
    Specified by:
    
    asReversed in interface ReversibleDoubleIterable
  - forEachInBoth
```
public void forEachInBoth(DoubleList other,
                          DoubleDoubleProcedure procedure)
```
    Description copied from interface: DoubleList
    
    This method iterates over two CharList instances of the same size together using the specified CharCharProcedure.
    
    Specified by:
    
    forEachInBoth in interface DoubleList
  - forEachWithIndex
```
public void forEachWithIndex(DoubleIntProcedure procedure)
```
    Specified by:
    
    forEachWithIndex in interface OrderedDoubleIterable
  - injectIntoWithIndex
```
public <T> T injectIntoWithIndex(T injectedValue,
                                 ObjectDoubleIntToObjectFunction<? super T,? extends T> function)
```
    Specified by:
    
    injectIntoWithIndex in interface OrderedDoubleIterable
    
    Specified by:
    
    injectIntoWithIndex in interface ReversibleDoubleIterable
  - distinct
```
public MutableDoubleList distinct()
```
    Specified by:
    
    distinct in interface DoubleList
    
    Specified by:
    
    distinct in interface MutableDoubleList
    
    Specified by:
    
    distinct in interface ReversibleDoubleIterable
    
    Since:
    
    6.0.
  - subList
```
public MutableDoubleList subList(int fromIndex,
                                 int toIndex)
```
    Specified by:
    
    subList in interface DoubleList
    
    Specified by:
    
    subList in interface MutableDoubleList
    
    See Also:
    
    List.subList(int fromIndex, int toIndex)
  - zipDouble
```
public MutableList<DoubleDoublePair> zipDouble(DoubleIterable iterable)
```
    Description copied from interface: MutableDoubleList
    
    Returns a MutableList formed from this MutableDoubleList and another DoubleList by combining corresponding elements in pairs. If one of the two DoubleLists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zipDouble in interface DoubleList
    
    Specified by:
    
    zipDouble in interface MutableDoubleList
    
    Since:
    
    9.1.
  - zip
```
public <T> MutableList<DoubleObjectPair<T>> zip(java.lang.Iterable<T> iterable)
```
    Description copied from interface: MutableDoubleList
    
    Returns a MutableList formed from this MutableDoubleList and a ListIterable by combining corresponding elements in pairs. If one of the two Lists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface DoubleList
    
    Specified by:
    
    zip in interface MutableDoubleList
    
    Since:
    
    9.1.
  - selectWithIndex
```
public MutableDoubleList selectWithIndex(DoubleIntPredicate predicate)
```
    Returns a new MutableDoubleList including all elements with corresponding indexes matching the specified predicate.
    
    Specified by:
    
    selectWithIndex in interface DoubleList
    
    Specified by:
    
    selectWithIndex in interface MutableDoubleList
    
    Specified by:
    
    selectWithIndex in interface OrderedDoubleIterable
    
    Specified by:
    
    selectWithIndex in interface ReversibleDoubleIterable
    
    Since:
    
    11.1.
  - selectWithIndex
```
public <R extends MutableDoubleCollection> R selectWithIndex(DoubleIntPredicate predicate,
                                                             R target)
```
    Returns a new MutableDoubleCollection including all elements with corresponding indexes matching the specified predicate.
    
    Specified by:
    
    selectWithIndex in interface OrderedDoubleIterable
    
    Since:
    
    11.1.
  - rejectWithIndex
```
public MutableDoubleList rejectWithIndex(DoubleIntPredicate predicate)
```
    Returns a new MutableDoubleList excluding all elements with corresponding indexes matching the specified predicate.
    
    Specified by:
    
    rejectWithIndex in interface DoubleList
    
    Specified by:
    
    rejectWithIndex in interface MutableDoubleList
    
    Specified by:
    
    rejectWithIndex in interface OrderedDoubleIterable
    
    Specified by:
    
    rejectWithIndex in interface ReversibleDoubleIterable
    
    Since:
    
    11.1.
  - rejectWithIndex
```
public <R extends MutableDoubleCollection> R rejectWithIndex(DoubleIntPredicate predicate,
                                                             R target)
```
    Returns a new MutableDoubleCollection excluding all elements with corresponding indexes matching the specified predicate.
    
    Specified by:
    
    rejectWithIndex in interface OrderedDoubleIterable
    
    Since:
    
    11.1.
  - collectWithIndex
```
public <V> MutableList<V> collectWithIndex(DoubleIntToObjectFunction<? extends V> function)
```
    Returns a new MutableList using results obtained by applying the specified function to each element and its corresponding index.
    
    Specified by:
    
    collectWithIndex in interface DoubleList
    
    Specified by:
    
    collectWithIndex in interface MutableDoubleList
    
    Specified by:
    
    collectWithIndex in interface OrderedDoubleIterable
    
    Specified by:
    
    collectWithIndex in interface ReversibleDoubleIterable
    
    Since:
    
    9.1.
  - collectWithIndex
```
public <V,R extends java.util.Collection<V>> R collectWithIndex(DoubleIntToObjectFunction<? extends V> function,
                                                                      R target)
```
    Adds elements to the target Collection using results obtained by applying the specified function to each element and its corresponding index.
    
    Specified by:
    
    collectWithIndex in interface OrderedDoubleIterable
    
    Since:
    
    9.1.
  - toStack
```
public MutableDoubleStack toStack()
```
    Description copied from interface: OrderedDoubleIterable
    
    Converts the collection to a DoubleStack.
    
    Specified by:
    
    toStack in interface OrderedDoubleIterable
  - spliterator
```
public java.util.Spliterator.OfDouble spliterator()
```
    This function needs to be synchronized manually
    
    Specified by:
    
    spliterator in interface DoubleList

Class SynchronizedDoubleList

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.collection.mutable.primitive.AbstractSynchronizedDoubleCollection

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.DoubleIterable

Methods inherited from interface org.eclipse.collections.api.list.primitive.DoubleList

Methods inherited from interface org.eclipse.collections.api.collection.primitive.MutableDoubleCollection

Methods inherited from interface org.eclipse.collections.api.list.primitive.MutableDoubleList

Methods inherited from interface org.eclipse.collections.api.PrimitiveIterable

Field Detail

serialVersionUID

Constructor Detail

SynchronizedDoubleList

SynchronizedDoubleList

Method Detail

getMutableDoubleList

get

getFirst

getLast

indexOf

lastIndexOf

addAtIndex

addAllAtIndex

addAllAtIndex

removeAtIndex

set

with

without

withAll

withoutAll

select

boxed

reject

collect

sortThis

sortThis

sortThisBy

sortThisBy

shuffleThis

shuffleThis

binarySearch

dotProduct

equals

hashCode

asLazy

asUnmodifiable

asSynchronized

toImmutable

newEmpty

reverseThis

toReversed

asReversed

forEachInBoth

forEachWithIndex

injectIntoWithIndex

distinct

subList

zipDouble

zip

selectWithIndex

selectWithIndex

rejectWithIndex

rejectWithIndex

collectWithIndex

collectWithIndex

toStack

spliterator