DoubleList (abacus-util 1.21.7 API)

java.lang.Object
- com.landawn.abacus.util.PrimitiveList<Double,double[],DoubleList>
- - com.landawn.abacus.util.DoubleList

All Implemented Interfaces:

Serializable, RandomAccess
```
public final class DoubleList
extends PrimitiveList<Double,double[],DoubleList>
```
Since:

0.8

Author:

Haiyang Li

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`DoubleList()`
`DoubleList(double[] a)` The specified array is used as the element array for this list without copying action.
`DoubleList(double[] a, int size)`
`DoubleList(int initialCapacity)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<E extends Exception> void`	`accept(Throwables.Consumer<? super DoubleList,E> action)`
`<E extends Exception> If.OrElse`	`acceptIfNotEmpty(Throwables.Consumer<? super DoubleList,E> action)` Accept if not empty.
`void`	`add(double e)`
`void`	`add(int index, double e)`
`boolean`	`addAll(double[] a)` Adds the all.
`boolean`	`addAll(DoubleList c)` Adds the all.
`boolean`	`addAll(int index, double[] a)` Adds the all.
`boolean`	`addAll(int index, DoubleList c)` Adds the all.
`<E extends Exception> boolean`	`allMatch(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter)`
`<E extends Exception> boolean`	`allMatch(Throwables.DoublePredicate<E> filter)` Returns whether all elements of this List match the provided predicate.
`<E extends Exception> boolean`	`anyMatch(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter)`
`<E extends Exception> boolean`	`anyMatch(Throwables.DoublePredicate<E> filter)` Returns whether any elements of this List match the provided predicate.
`<R,E extends Exception> R`	`apply(Throwables.Function<? super DoubleList,R,E> func)`
`<R,E extends Exception> u.Optional<R>`	`applyIfNotEmpty(Throwables.Function<? super DoubleList,R,E> func)` Apply if not empty.
`double[]`	`array()` Returns the original element array without copying.
`u.OptionalDouble`	`average()`
`u.OptionalDouble`	`average(int fromIndex, int toIndex)`
`int`	`binarySearch(double key)` This List should be sorted first.
`int`	`binarySearch(int fromIndex, int toIndex, double key)` This List should be sorted first.
`List<Double>`	`boxed()`
`List<Double>`	`boxed(int fromIndex, int toIndex)`
`void`	`clear()` Clear.
`boolean`	`contains(double e)`
`boolean`	`containsAll(double[] a)`
`boolean`	`containsAll(DoubleList c)`
`boolean`	`containsAny(double[] a)`
`boolean`	`containsAny(DoubleList c)`
`DoubleList`	`copy()`
`DoubleList`	`copy(int fromIndex, int toIndex)`
`DoubleList`	`copy(int from, int to, int step)`
`static DoubleList`	`copyOf(double[] a)`
`static DoubleList`	`copyOf(double[] a, int fromIndex, int toIndex)`
`<E extends Exception> int`	`count(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter)`
`<E extends Exception> int`	`count(Throwables.DoublePredicate<E> filter)`
`double`	`delete(int index)`
`void`	`deleteAll(int... indices)`
`void`	`deleteRange(int fromIndex, int toIndex)`
`DoubleList`	`difference(double[] a)`
`DoubleList`	`difference(DoubleList b)`
`boolean`	`disjoint(double[] b)`
`boolean`	`disjoint(DoubleList c)`
`DoubleList`	`distinct(int fromIndex, int toIndex)`
`boolean`	`equals(Object obj)`
`void`	`fill(double val)`
`void`	`fill(int fromIndex, int toIndex, double val)`
`<E extends Exception> DoubleList`	`filter(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter)`
`<E extends Exception> DoubleList`	`filter(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter, int max)`
`<E extends Exception> DoubleList`	`filter(Throwables.DoublePredicate<E> filter)`
`<E extends Exception> DoubleList`	`filter(Throwables.DoublePredicate<E> filter, int max)`
`<E extends Exception> u.OptionalDouble`	`findFirst(Throwables.DoublePredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findFirstIndex(Throwables.DoublePredicate<E> predicate)` Find first index.
`<E extends Exception> u.OptionalDouble`	`findLast(Throwables.DoublePredicate<E> predicate)`
`<E extends Exception> u.OptionalInt`	`findLastIndex(Throwables.DoublePredicate<E> predicate)` Find last index.
`u.OptionalDouble`	`first()`
`<E extends Exception> void`	`forEach(int fromIndex, int toIndex, Throwables.DoubleConsumer<E> action)`
`<E extends Exception> void`	`forEach(Throwables.DoubleConsumer<E> action)`
`<E extends Exception> void`	`forEachIndexed(int fromIndex, int toIndex, Throwables.IndexedDoubleConsumer<E> action)`
`<E extends Exception> void`	`forEachIndexed(Throwables.IndexedDoubleConsumer<E> action)`
`static DoubleList`	`from(Collection<Double> c)`
`static DoubleList`	`from(Collection<Double> c, double defaultForNull)`
`static DoubleList`	`from(Collection<Double> c, int fromIndex, int toIndex)`
`static DoubleList`	`from(Collection<Double> c, int fromIndex, int toIndex, double defaultForNull)`
`double`	`get(int index)`
`boolean`	`hasDuplicates()` Checks for duplicates.
`int`	`hashCode()`
`int`	`indexOf(double e)`
`int`	`indexOf(int fromIndex, double e)`
`DoubleList`	`intersection(double[] a)`
`DoubleList`	`intersection(DoubleList b)`
`boolean`	`isEmpty()` Checks if is empty.
`DoubleIterator`	`iterator()`
`String`	`join(int fromIndex, int toIndex, char delimiter)`
`String`	`join(int fromIndex, int toIndex, String delimiter)`
`u.OptionalDouble`	`kthLargest(int k)`
`u.OptionalDouble`	`kthLargest(int fromIndex, int toIndex, int k)`
`u.OptionalDouble`	`last()`
`int`	`lastIndexOf(double e)` Last index of.
`int`	`lastIndexOf(int fromIndex, double e)` Last index of.
`<E extends Exception> DoubleList`	`map(int fromIndex, int toIndex, Throwables.DoubleUnaryOperator<E> mapper)`
`<E extends Exception> DoubleList`	`map(Throwables.DoubleUnaryOperator<E> mapper)`
`<T,E extends Exception> List<T>`	`mapToObj(int fromIndex, int toIndex, Throwables.DoubleFunction<? extends T,E> mapper)` Map to obj.
`<T,E extends Exception> List<T>`	`mapToObj(Throwables.DoubleFunction<? extends T,E> mapper)` Map to obj.
`u.OptionalDouble`	`max()`
`u.OptionalDouble`	`max(int fromIndex, int toIndex)`
`u.OptionalDouble`	`median()`
`u.OptionalDouble`	`median(int fromIndex, int toIndex)`
`u.OptionalDouble`	`min()`
`u.OptionalDouble`	`min(int fromIndex, int toIndex)`
`<E extends Exception> boolean`	`noneMatch(int fromIndex, int toIndex, Throwables.DoublePredicate<E> filter)`
`<E extends Exception> boolean`	`noneMatch(Throwables.DoublePredicate<E> filter)` Returns whether no elements of this List match the provided predicate.
`int`	`occurrencesOf(double objectToFind)`
`static DoubleList`	`of(double... a)`
`static DoubleList`	`of(double[] a, int size)`
`void`	`parallelSort()` Parallel sort.
`static DoubleList`	`random(int len)`
`<E extends Exception> double`	`reduce(double identity, Throwables.DoubleBinaryOperator<E> accumulator)` This is equivalent to:
`<E extends Exception> u.OptionalDouble`	`reduce(Throwables.DoubleBinaryOperator<E> accumulator)` This is equivalent to:
`boolean`	`remove(double e)`
`boolean`	`removeAll(double[] a)` Removes the all.
`boolean`	`removeAll(DoubleList c)` Removes the all.
`boolean`	`removeAllOccurrences(double e)` Removes the all occurrences.
`<E extends Exception> boolean`	`removeIf(Throwables.DoublePredicate<E> p)` Removes the if.
`static DoubleList`	`repeat(double element, int len)`
`int`	`replaceAll(double oldVal, double newVal)`
`<E extends Exception> void`	`replaceAll(Throwables.DoubleUnaryOperator<E> operator)`
`<E extends Exception> boolean`	`replaceIf(Throwables.DoublePredicate<E> predicate, double newValue)`
`boolean`	`retainAll(double[] a)`
`boolean`	`retainAll(DoubleList c)`
`void`	`reverse()` Reverse.
`void`	`reverse(int fromIndex, int toIndex)`
`void`	`reverseSort()` Reverse sort.
`void`	`rotate(int distance)`
`double`	`set(int index, double e)`
`void`	`shuffle()` Shuffle.
`void`	`shuffle(Random rnd)`
`int`	`size()`
`void`	`sort()` Sort.
`List<DoubleList>`	`split(int fromIndex, int toIndex, int chunkSize)` Returns List of `DoubleList` with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
`DoubleStream`	`stream()`
`DoubleStream`	`stream(int fromIndex, int toIndex)`
`double`	`sum()`
`double`	`sum(int fromIndex, int toIndex)`
`void`	`swap(int i, int j)`
`DoubleList`	`symmetricDifference(double[] a)`
`DoubleList`	`symmetricDifference(DoubleList b)`
`double[]`	`toArray()`
`<C extends Collection<Double>> C`	`toCollection(int fromIndex, int toIndex, IntFunction<? extends C> supplier)`
`<K,A,D,E extends Exception> Map<K,D>`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<Double,A,D> downstream)`
`<K,A,D,M extends Map<K,D>,E extends Exception> M`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<Double,A,D> downstream, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception> Map<K,V>`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception> M`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, IntFunction<? extends M> mapFactory)`
`<K,V,E extends Exception,E2 extends Exception,E3 extends Exception> Map<K,V>`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, Throwables.BinaryOperator<V,E3> mergeFunction)`
`<K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception,E3 extends Exception> M`	`toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, Throwables.BinaryOperator<V,E3> mergeFunction, IntFunction<? extends M> mapFactory)`
`Multiset<Double>`	`toMultiset(int fromIndex, int toIndex, IntFunction<Multiset<Double>> supplier)`
`DoubleList`	`top(int n)`
`DoubleList`	`top(int n, Comparator<? super Double> cmp)`
`DoubleList`	`top(int fromIndex, int toIndex, int n)`
`DoubleList`	`top(int fromIndex, int toIndex, int n, Comparator<? super Double> cmp)`
`String`	`toString()`
`DoubleList`	`trimToSize()` Trim to size.

Methods inherited from class com.landawn.abacus.util.PrimitiveList
distinct, join, join, join, join, println, split, toCollection, toList, toList, toMultiset, toMultiset, toMultiset, toSet, toSet

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

Constructor Detail
- DoubleList
```
public DoubleList()
```
- DoubleList
```
public DoubleList(int initialCapacity)
```
- DoubleList
```
public DoubleList(double[] a)
```
  The specified array is used as the element array for this list without copying action.
  
  Parameters:
  
  a -
- DoubleList
```
public DoubleList(double[] a,
                  int size)
```

Method Detail

of

@SafeVarargs
public static DoubleList of(double... a)

Parameters:: a -
Returns:

of

public static DoubleList of(double[] a,
                            int size)

Parameters:: a -; size -
Returns:

copyOf

public static DoubleList copyOf(double[] a)

Parameters:: a -
Returns:

copyOf

public static DoubleList copyOf(double[] a,
                                int fromIndex,
                                int toIndex)

Parameters:: a -; fromIndex -; toIndex -
Returns:

from

public static DoubleList from(Collection<Double> c)

Parameters:: c -
Returns:

from

public static DoubleList from(Collection<Double> c,
                              double defaultForNull)

Parameters:: c -; defaultForNull -
Returns:

from

public static DoubleList from(Collection<Double> c,
                              int fromIndex,
                              int toIndex)

Parameters:: c -; fromIndex -; toIndex -
Returns:

from

public static DoubleList from(Collection<Double> c,
                              int fromIndex,
                              int toIndex,
                              double defaultForNull)

Parameters:: c -; fromIndex -; toIndex -; defaultForNull -
Returns:

repeat

public static DoubleList repeat(double element,
                                int len)

Parameters:: element -; len -
Returns:

random

public static DoubleList random(int len)

Parameters:: len -
Returns:

array
```
public double[] array()
```
Returns the original element array without copying.

Specified by:

array in class PrimitiveList<Double,double[],DoubleList>

Returns:

get
```
public double get(int index)
```
Parameters:

index -

Returns:

set

public double set(int index,
                  double e)

Parameters:: index -; e -
Returns:

add
```
public void add(double e)
```
Parameters:

e -

add

public void add(int index,
                double e)

Parameters:: index -; e -

addAll
```
public boolean addAll(DoubleList c)
```
Adds the all.

Parameters:

c -

Returns:

true, if successful

addAll

public boolean addAll(int index,
                      DoubleList c)

Adds the all.

Parameters:: index -; c -
Returns:: true, if successful

addAll
```
public boolean addAll(double[] a)
```
Adds the all.

Specified by:

addAll in class PrimitiveList<Double,double[],DoubleList>

Parameters:

a -

Returns:

true, if successful

addAll
```
public boolean addAll(int index,
                      double[] a)
```
Adds the all.

Specified by:

addAll in class PrimitiveList<Double,double[],DoubleList>

Parameters:

index -

a -

Returns:

true, if successful

remove
```
public boolean remove(double e)
```
Parameters:

e -

Returns:

true if this list contained the specified element

removeAllOccurrences
```
public boolean removeAllOccurrences(double e)
```
Removes the all occurrences.

Parameters:

e -

Returns:

true, if successful

removeAll
```
public boolean removeAll(DoubleList c)
```
Removes the all.

Parameters:

c -

Returns:

true, if successful

removeAll
```
public boolean removeAll(double[] a)
```
Removes the all.

Specified by:

removeAll in class PrimitiveList<Double,double[],DoubleList>

Parameters:

a -

Returns:

true, if successful

removeIf

public <E extends Exception> boolean removeIf(Throwables.DoublePredicate<E> p)
                                       throws E extends Exception

Removes the if.

Type Parameters:: E -
Parameters:: p -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

retainAll
```
public boolean retainAll(DoubleList c)
```
Parameters:

c -

Returns:

true, if successful

retainAll
```
public boolean retainAll(double[] a)
```
Parameters:

a -

Returns:

true, if successful

delete
```
public double delete(int index)
```
Parameters:

index -

Returns:

deleteAll
```
@SafeVarargs
public final void deleteAll(int... indices)
```
Specified by:

deleteAll in class PrimitiveList<Double,double[],DoubleList>

Parameters:

indices -

deleteRange
```
public void deleteRange(int fromIndex,
                        int toIndex)
```
Specified by:

deleteRange in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

replaceAll

public int replaceAll(double oldVal,
                      double newVal)

Parameters:: oldVal -; newVal -
Returns:

replaceAll

public <E extends Exception> void replaceAll(Throwables.DoubleUnaryOperator<E> operator)
                                      throws E extends Exception

Type Parameters:: E -
Parameters:: operator -
Throws:: E - the e; E extends Exception

replaceIf

public <E extends Exception> boolean replaceIf(Throwables.DoublePredicate<E> predicate,
                                               double newValue)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -; newValue -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

fill
```
public void fill(double val)
```
Parameters:

val -

fill

public void fill(int fromIndex,
                 int toIndex,
                 double val)

Parameters:: fromIndex -; toIndex -; val -

contains
```
public boolean contains(double e)
```
Parameters:

e -

Returns:

true, if successful

containsAll
```
public boolean containsAll(DoubleList c)
```
Parameters:

c -

Returns:

true, if successful

containsAll
```
public boolean containsAll(double[] a)
```
Specified by:

containsAll in class PrimitiveList<Double,double[],DoubleList>

Parameters:

a -

Returns:

true, if successful

containsAny
```
public boolean containsAny(DoubleList c)
```
Parameters:

c -

Returns:

true, if successful

containsAny
```
public boolean containsAny(double[] a)
```
Specified by:

containsAny in class PrimitiveList<Double,double[],DoubleList>

Parameters:

a -

Returns:

true, if successful

disjoint
```
public boolean disjoint(DoubleList c)
```
Parameters:

c -

Returns:

true, if successful

disjoint
```
public boolean disjoint(double[] b)
```
Specified by:

disjoint in class PrimitiveList<Double,double[],DoubleList>

Parameters:

b -

Returns:

true, if successful

intersection
```
public DoubleList intersection(DoubleList b)
```
Parameters:

b -

Returns:

See Also:

IntList.intersection(IntList)

intersection

public DoubleList intersection(double[] a)

Parameters:: a -
Returns:

difference
```
public DoubleList difference(DoubleList b)
```
Parameters:

b -

Returns:

See Also:

IntList.difference(IntList)

difference

public DoubleList difference(double[] a)

Parameters:: a -
Returns:

symmetricDifference
```
public DoubleList symmetricDifference(DoubleList b)
```
Parameters:

b -

Returns:

this.difference(b).addAll(b.difference(this))

See Also:

IntList.symmetricDifference(IntList)

symmetricDifference

public DoubleList symmetricDifference(double[] a)

Parameters:: a -
Returns:

occurrencesOf

public int occurrencesOf(double objectToFind)

Parameters:: objectToFind -
Returns:

indexOf
```
public int indexOf(double e)
```
Parameters:

e -

Returns:

indexOf

public int indexOf(int fromIndex,
                   double e)

Parameters:: fromIndex -; e -
Returns:

lastIndexOf
```
public int lastIndexOf(double e)
```
Last index of.

Parameters:

e -

Returns:

lastIndexOf
```
public int lastIndexOf(int fromIndex,
                       double e)
```
Last index of.

Parameters:

fromIndex - the start index to traverse backwards from. Inclusive.

e -

Returns:

min
```
public u.OptionalDouble min()
```

min

public u.OptionalDouble min(int fromIndex,
                            int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

median
```
public u.OptionalDouble median()
```

median

public u.OptionalDouble median(int fromIndex,
                               int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

max
```
public u.OptionalDouble max()
```

max

public u.OptionalDouble max(int fromIndex,
                            int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

kthLargest

public u.OptionalDouble kthLargest(int k)

Parameters:: k -
Returns:

kthLargest

public u.OptionalDouble kthLargest(int fromIndex,
                                   int toIndex,
                                   int k)

Parameters:: fromIndex -; toIndex -; k -
Returns:

sum
```
public double sum()
```

sum

public double sum(int fromIndex,
                  int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

average
```
public u.OptionalDouble average()
```

average

public u.OptionalDouble average(int fromIndex,
                                int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

forEach

public <E extends Exception> void forEach(Throwables.DoubleConsumer<E> action)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

forEach

public <E extends Exception> void forEach(int fromIndex,
                                          int toIndex,
                                          Throwables.DoubleConsumer<E> action)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; action -
Throws:: E - the e; E extends Exception

forEachIndexed

public <E extends Exception> void forEachIndexed(Throwables.IndexedDoubleConsumer<E> action)
                                          throws E extends Exception

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

forEachIndexed

public <E extends Exception> void forEachIndexed(int fromIndex,
                                                 int toIndex,
                                                 Throwables.IndexedDoubleConsumer<E> action)
                                          throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; action -
Throws:: E - the e; E extends Exception

first
```
public u.OptionalDouble first()
```

last
```
public u.OptionalDouble last()
```

findFirst

public <E extends Exception> u.OptionalDouble findFirst(Throwables.DoublePredicate<E> predicate)
                                                 throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findLast

public <E extends Exception> u.OptionalDouble findLast(Throwables.DoublePredicate<E> predicate)
                                                throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findFirstIndex

public <E extends Exception> u.OptionalInt findFirstIndex(Throwables.DoublePredicate<E> predicate)
                                                   throws E extends Exception

Find first index.

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

findLastIndex

public <E extends Exception> u.OptionalInt findLastIndex(Throwables.DoublePredicate<E> predicate)
                                                  throws E extends Exception

Find last index.

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E - the e; E extends Exception

allMatch
```
public <E extends Exception> boolean allMatch(Throwables.DoublePredicate<E> filter)
                                       throws E extends Exception
```
Returns whether all elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

allMatch

public <E extends Exception> boolean allMatch(int fromIndex,
                                              int toIndex,
                                              Throwables.DoublePredicate<E> filter)
                                       throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

anyMatch
```
public <E extends Exception> boolean anyMatch(Throwables.DoublePredicate<E> filter)
                                       throws E extends Exception
```
Returns whether any elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

anyMatch

public <E extends Exception> boolean anyMatch(int fromIndex,
                                              int toIndex,
                                              Throwables.DoublePredicate<E> filter)
                                       throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

noneMatch
```
public <E extends Exception> boolean noneMatch(Throwables.DoublePredicate<E> filter)
                                        throws E extends Exception
```
Returns whether no elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

true, if successful

Throws:

E - the e

E extends Exception

noneMatch

public <E extends Exception> boolean noneMatch(int fromIndex,
                                               int toIndex,
                                               Throwables.DoublePredicate<E> filter)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

count

public <E extends Exception> int count(Throwables.DoublePredicate<E> filter)
                                throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:
Throws:: E - the e; E extends Exception

count

public <E extends Exception> int count(int fromIndex,
                                       int toIndex,
                                       Throwables.DoublePredicate<E> filter)
                                throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> DoubleList filter(Throwables.DoublePredicate<E> filter)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:: a new List with the elements match the provided predicate.
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> DoubleList filter(int fromIndex,
                                               int toIndex,
                                               Throwables.DoublePredicate<E> filter)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -
Returns:
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> DoubleList filter(Throwables.DoublePredicate<E> filter,
                                               int max)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: filter -; max -
Returns:: a new List with the elements match the provided predicate.
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> DoubleList filter(int fromIndex,
                                               int toIndex,
                                               Throwables.DoublePredicate<E> filter,
                                               int max)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; filter -; max -
Returns:
Throws:: E - the e; E extends Exception

map

public <E extends Exception> DoubleList map(Throwables.DoubleUnaryOperator<E> mapper)
                                     throws E extends Exception

Type Parameters:: E -
Parameters:: mapper -
Returns:
Throws:: E - the e; E extends Exception

map

public <E extends Exception> DoubleList map(int fromIndex,
                                            int toIndex,
                                            Throwables.DoubleUnaryOperator<E> mapper)
                                     throws E extends Exception

Type Parameters:: E -
Parameters:: fromIndex -; toIndex -; mapper -
Returns:
Throws:: E - the e; E extends Exception

mapToObj

public <T,E extends Exception> List<T> mapToObj(Throwables.DoubleFunction<? extends T,E> mapper)
                                         throws E extends Exception

Map to obj.

Type Parameters:: T -; E -
Parameters:: mapper -
Returns:
Throws:: E - the e; E extends Exception

mapToObj

public <T,E extends Exception> List<T> mapToObj(int fromIndex,
                                                int toIndex,
                                                Throwables.DoubleFunction<? extends T,E> mapper)
                                         throws E extends Exception

Map to obj.

Type Parameters:: T -; E -
Parameters:: fromIndex -; toIndex -; mapper -
Returns:
Throws:: E - the e; E extends Exception

reduce

public <E extends Exception> u.OptionalDouble reduce(Throwables.DoubleBinaryOperator<E> accumulator)
                                              throws E extends Exception

This is equivalent to:

 
    if (isEmpty()) {
        return OptionalDouble.empty();
    }

    double result = elementData[0];

    for (int i = 1; i < size; i++) {
        result = accumulator.applyAsDouble(result, elementData[i]);
    }

    return OptionalDouble.of(result);

Type Parameters:: E -
Parameters:: accumulator -
Returns:
Throws:: E - the e; E extends Exception

reduce

public <E extends Exception> double reduce(double identity,
                                           Throwables.DoubleBinaryOperator<E> accumulator)
                                    throws E extends Exception

This is equivalent to:

 
     if (isEmpty()) {
         return identity;
     }

     double result = identity;

     for (int i = 0; i < size; i++) {
         result = accumulator.applyAsDouble(result, elementData[i]);
    }

     return result;

Type Parameters:: E -
Parameters:: identity -; accumulator -
Returns:
Throws:: E - the e; E extends Exception

hasDuplicates
```
public boolean hasDuplicates()
```
Checks for duplicates.

Specified by:

hasDuplicates in class PrimitiveList<Double,double[],DoubleList>

Returns:

true, if successful

distinct
```
public DoubleList distinct(int fromIndex,
                           int toIndex)
```
Specified by:

distinct in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

Returns:

top
```
public DoubleList top(int n)
```
Parameters:

n -

Returns:

top

public DoubleList top(int fromIndex,
                      int toIndex,
                      int n)

Parameters:: fromIndex -; toIndex -; n -
Returns:

top

public DoubleList top(int n,
                      Comparator<? super Double> cmp)

Parameters:: n -; cmp -
Returns:

top

public DoubleList top(int fromIndex,
                      int toIndex,
                      int n,
                      Comparator<? super Double> cmp)

Parameters:: fromIndex -; toIndex -; n -; cmp -
Returns:

sort
```
public void sort()
```
Sort.

Specified by:

sort in class PrimitiveList<Double,double[],DoubleList>

parallelSort
```
public void parallelSort()
```
Parallel sort.

reverseSort
```
public void reverseSort()
```
Reverse sort.

binarySearch
```
public int binarySearch(double key)
```
This List should be sorted first.

Parameters:

key -

Returns:

binarySearch

public int binarySearch(int fromIndex,
                        int toIndex,
                        double key)

This List should be sorted first.

Parameters:: fromIndex -; toIndex -; key -
Returns:

reverse
```
public void reverse()
```
Reverse.

Specified by:

reverse in class PrimitiveList<Double,double[],DoubleList>

reverse
```
public void reverse(int fromIndex,
                    int toIndex)
```
Specified by:

reverse in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

rotate
```
public void rotate(int distance)
```
Specified by:

rotate in class PrimitiveList<Double,double[],DoubleList>

Parameters:

distance -

shuffle
```
public void shuffle()
```
Shuffle.

Specified by:

shuffle in class PrimitiveList<Double,double[],DoubleList>

shuffle
```
public void shuffle(Random rnd)
```
Specified by:

shuffle in class PrimitiveList<Double,double[],DoubleList>

Parameters:

rnd -

swap
```
public void swap(int i,
                 int j)
```
Specified by:

swap in class PrimitiveList<Double,double[],DoubleList>

Parameters:

i -

j -

copy
```
public DoubleList copy()
```
Specified by:

copy in class PrimitiveList<Double,double[],DoubleList>

Returns:

a copy of this List

copy
```
public DoubleList copy(int fromIndex,
                       int toIndex)
```
Specified by:

copy in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

Returns:

copy
```
public DoubleList copy(int from,
                       int to,
                       int step)
```
Specified by:

copy in class PrimitiveList<Double,double[],DoubleList>

Parameters:

from -

to -

step -

Returns:

See Also:

CommonUtil.copyOfRange(int[], int, int, int)

split
```
public List<DoubleList> split(int fromIndex,
                              int toIndex,
                              int chunkSize)
```
Returns List of DoubleList with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).

Specified by:

split in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

join
```
public String join(int fromIndex,
                   int toIndex,
                   char delimiter)
```
Specified by:

join in class PrimitiveList<Double,double[],DoubleList>

Parameters:

fromIndex -

toIndex -

delimiter -

Returns:

join

public String join(int fromIndex,
                   int toIndex,
                   String delimiter)

Specified by:: join in class PrimitiveList<Double,double[],DoubleList>
Parameters:: fromIndex -; toIndex -; delimiter -
Returns:

trimToSize
```
public DoubleList trimToSize()
```
Trim to size.

Specified by:

trimToSize in class PrimitiveList<Double,double[],DoubleList>

Returns:

clear
```
public void clear()
```
Clear.

Specified by:

clear in class PrimitiveList<Double,double[],DoubleList>

isEmpty
```
public boolean isEmpty()
```
Checks if is empty.

Specified by:

isEmpty in class PrimitiveList<Double,double[],DoubleList>

Returns:

true, if is empty

size
```
public int size()
```
Specified by:

size in class PrimitiveList<Double,double[],DoubleList>

boxed
```
public List<Double> boxed()
```

boxed

public List<Double> boxed(int fromIndex,
                          int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

toArray
```
public double[] toArray()
```
Specified by:

toArray in class PrimitiveList<Double,double[],DoubleList>

toCollection

public <C extends Collection<Double>> C toCollection(int fromIndex,
                                                     int toIndex,
                                                     IntFunction<? extends C> supplier)

Specified by:: toCollection in class PrimitiveList<Double,double[],DoubleList>
Type Parameters:: C -
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMultiset

public Multiset<Double> toMultiset(int fromIndex,
                                   int toIndex,
                                   IntFunction<Multiset<Double>> supplier)

Specified by:: toMultiset in class PrimitiveList<Double,double[],DoubleList>
Parameters:: fromIndex -; toIndex -; supplier -
Returns:

toMap

public <K,V,E extends Exception,E2 extends Exception> Map<K,V> toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                                     Throwables.DoubleFunction<? extends V,E2> valueMapper)
                                                              throws E extends Exception,
                                                                     E2 extends Exception

Type Parameters:: K - the key type; V - the value type; E -; E2 -
Parameters:: keyMapper -; valueMapper -
Returns:
Throws:: E - the e; E2 - the e2; E extends Exception

toMap

public <K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception> M toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                                                 Throwables.DoubleFunction<? extends V,E2> valueMapper,
                                                                                 IntFunction<? extends M> mapFactory)
                                                                          throws E extends Exception,
                                                                                 E2 extends Exception

Type Parameters:: K - the key type; V - the value type; M -; E -; E2 -
Parameters:: keyMapper -; valueMapper -; mapFactory -
Returns:
Throws:: E - the e; E2 - the e2; E extends Exception

toMap

public <K,V,E extends Exception,E2 extends Exception,E3 extends Exception> Map<K,V> toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                                                          Throwables.DoubleFunction<? extends V,E2> valueMapper,
                                                                                          Throwables.BinaryOperator<V,E3> mergeFunction)
                                                                                   throws E extends Exception,
                                                                                          E2 extends Exception,
                                                                                          E3 extends Exception

Type Parameters:: K - the key type; V - the value type; E -; E2 -; E3 -
Parameters:: keyMapper -; valueMapper -; mergeFunction -
Returns:
Throws:: E - the e; E2 - the e2; E3 - the e3; E extends Exception

toMap

public <K,V,M extends Map<K,V>,E extends Exception,E2 extends Exception,E3 extends Exception> M toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                                                                      Throwables.DoubleFunction<? extends V,E2> valueMapper,
                                                                                                      Throwables.BinaryOperator<V,E3> mergeFunction,
                                                                                                      IntFunction<? extends M> mapFactory)
                                                                                               throws E extends Exception,
                                                                                                      E2 extends Exception,
                                                                                                      E3 extends Exception

Type Parameters:: K - the key type; V - the value type; M -; E -; E2 -; E3 -
Parameters:: keyMapper -; valueMapper -; mergeFunction -; mapFactory -
Returns:
Throws:: E - the e; E2 - the e2; E3 - the e3; E extends Exception

toMap

public <K,A,D,E extends Exception> Map<K,D> toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                  Collector<Double,A,D> downstream)
                                           throws E extends Exception

Type Parameters:: K - the key type; A -; D -; E -
Parameters:: keyMapper -; downstream -
Returns:
Throws:: E - the e; E extends Exception

toMap

public <K,A,D,M extends Map<K,D>,E extends Exception> M toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
                                                              Collector<Double,A,D> downstream,
                                                              IntFunction<? extends M> mapFactory)
                                                       throws E extends Exception

Type Parameters:: K - the key type; A -; D -; M -; E -
Parameters:: keyMapper -; downstream -; mapFactory -
Returns:
Throws:: E - the e; E extends Exception

iterator
```
public DoubleIterator iterator()
```

stream
```
public DoubleStream stream()
```

stream

public DoubleStream stream(int fromIndex,
                           int toIndex)

Parameters:: fromIndex -; toIndex -
Returns:

apply

public <R,E extends Exception> R apply(Throwables.Function<? super DoubleList,R,E> func)
                                throws E extends Exception

Specified by:: apply in class PrimitiveList<Double,double[],DoubleList>
Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

applyIfNotEmpty

public <R,E extends Exception> u.Optional<R> applyIfNotEmpty(Throwables.Function<? super DoubleList,R,E> func)
                                                      throws E extends Exception

Apply if not empty.

Specified by:: applyIfNotEmpty in class PrimitiveList<Double,double[],DoubleList>
Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

accept

public <E extends Exception> void accept(Throwables.Consumer<? super DoubleList,E> action)
                                  throws E extends Exception

Specified by:: accept in class PrimitiveList<Double,double[],DoubleList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

acceptIfNotEmpty

public <E extends Exception> If.OrElse acceptIfNotEmpty(Throwables.Consumer<? super DoubleList,E> action)
                                                 throws E extends Exception

Accept if not empty.

Specified by:: acceptIfNotEmpty in class PrimitiveList<Double,double[],DoubleList>
Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

Parameters:

obj -

Returns:

true, if successful

toString
```
public String toString()
```
Overrides:

toString in class Object

Class DoubleList

Constructor Summary

Method Summary

Methods inherited from class com.landawn.abacus.util.PrimitiveList

Methods inherited from class java.lang.Object

Constructor Detail

DoubleList

DoubleList

DoubleList

DoubleList

Method Detail

of

of

copyOf

copyOf

from

from

from

from

repeat

random

array

get

set

add

add

addAll

addAll

addAll

addAll

remove

removeAllOccurrences

removeAll

removeAll

removeIf

retainAll

retainAll

delete

deleteAll

deleteRange

replaceAll

replaceAll

replaceIf

fill

fill

contains

containsAll

containsAll

containsAny

containsAny

disjoint

disjoint

intersection

intersection

difference

difference

symmetricDifference

symmetricDifference

occurrencesOf

indexOf

indexOf

lastIndexOf

lastIndexOf

min

min

median

median

max

max

kthLargest

kthLargest

sum

sum

average

average

forEach

forEach

forEachIndexed

forEachIndexed

first