Package com.landawn.abacus.util

Class DoubleList

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:

• N
• Array
• Iterables
• Iterators
• Serialized Form

Constructor Summary

Constructors

Constructor	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

Modifier and Type	Method	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(int index, double[] a)	Adds the all.
boolean	addAll(int index, DoubleList c)	Adds the all.
boolean	addAll(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,? extends R,E> func)
<R, E extends Exception> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super DoubleList,? extends 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 valueToFind)	This List should be sorted first.
int	binarySearch(int fromIndex, int toIndex, double valueToFind)	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 fromIndex, int toIndex, 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)
final void	deleteAllByIndices(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.
boolean	isSorted()
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)
void	moveRange(int fromIndex, int toIndex, int newPositionStartIndex)
<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.
boolean	removeDuplicates()
<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)
void	replaceRange(int fromIndex, int toIndex, double[] replacement)
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)
Multiset<Double>	toMultiset(int fromIndex, int toIndex, IntFunction<Multiset<Double>> supplier)
DoubleList	top(int n)
DoubleList	top(int fromIndex, int toIndex, int n)
DoubleList	top(int fromIndex, int toIndex, int n, Comparator<? super Double> cmp)
DoubleList	top(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 Details

DoubleList

public DoubleList()

DoubleList

public DoubleList(int initialCapacity)

Parameters:

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)

Parameters:

a -

size -

Method Details

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

@Beta
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.

Specified by:

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

Parameters:

c -

Returns:

addAll

public boolean addAll(int index,
 DoubleList c)

Adds the all.

Specified by:

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

Parameters:

index -

c -

Returns:

addAll

public boolean addAll(double[] a)

Adds the all.

Specified by:

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

Parameters:

a -

Returns:

addAll

public boolean addAll(int index,
 double[] a)

Adds the all.

Specified by:

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

Parameters:

index -

a -

Returns:

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:

removeAll

public boolean removeAll(DoubleList c)

Removes the all.

Specified by:

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

Parameters:

c -

Returns:

removeAll

public boolean removeAll(double[] a)

Removes the all.

Specified by:

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

Parameters:

a -

Returns:

removeIf

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

Removes the if.

Type Parameters:

E -

Parameters:

p -

Returns:

Throws:

E - the e

removeDuplicates

public boolean removeDuplicates()

Specified by:

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

Returns:

retainAll

public boolean retainAll(DoubleList c)

Specified by:

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

Parameters:

c -

Returns:

retainAll

public boolean retainAll(double[] a)

Specified by:

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

Parameters:

a -

Returns:

delete

public double delete(int index)

Parameters:

index -

Returns:

deleteAllByIndices

@SafeVarargs
public final void deleteAllByIndices(int... indices)

Specified by:

deleteAllByIndices 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 -

moveRange

public void moveRange(int fromIndex,
 int toIndex,
 int newPositionStartIndex)

Specified by:

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

Parameters:

fromIndex -

toIndex -

newPositionStartIndex -

replaceRange

public void replaceRange(int fromIndex,
 int toIndex,
 double[] replacement)

Specified by:

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

Parameters:

fromIndex -

toIndex -

replacement -

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

Type Parameters:

E -

Parameters:

operator -

Throws:

E - the e

replaceIf

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

Type Parameters:

E -

Parameters:

predicate -

newValue -

Returns:

Throws:

E - the e

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:

containsAny

public boolean containsAny(DoubleList c)

Specified by:

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

Parameters:

c -

Returns:

containsAny

public boolean containsAny(double[] a)

Specified by:

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

Parameters:

a -

Returns:

containsAll

public boolean containsAll(DoubleList c)

Specified by:

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

Parameters:

c -

Returns:

containsAll

public boolean containsAll(double[] a)

Specified by:

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

Parameters:

a -

Returns:

disjoint

public boolean disjoint(DoubleList c)

Specified by:

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

Parameters:

c -

Returns:

disjoint

public boolean disjoint(double[] b)

Specified by:

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

Parameters:

b -

Returns:

intersection

public DoubleList intersection(DoubleList b)

Specified by:

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

Parameters:

b -

Returns:

See Also:

• IntList.intersection(IntList)

intersection

public DoubleList intersection(double[] a)

Specified by:

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

Parameters:

a -

Returns:

difference

public DoubleList difference(DoubleList b)

Specified by:

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

Parameters:

b -

Returns:

See Also:

• IntList.difference(IntList)

difference

public DoubleList difference(double[] a)

Specified by:

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

Parameters:

a -

Returns:

symmetricDifference

public DoubleList symmetricDifference(DoubleList b)

Specified by:

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

Parameters:

b -

Returns:

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

See Also:

• IntList.symmetricDifference(IntList)

symmetricDifference

public DoubleList symmetricDifference(double[] a)

Specified by:

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

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()

Returns:

min

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

Parameters:

fromIndex -

toIndex -

Returns:

median

public u.OptionalDouble median()

Returns:

median

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

Parameters:

fromIndex -

toIndex -

Returns:

max

public u.OptionalDouble max()

Returns:

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()

Returns:

sum

public double sum(int fromIndex,
 int toIndex)

Parameters:

fromIndex -

toIndex -

Returns:

average

public u.OptionalDouble average()

Returns:

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

Type Parameters:

E -

Parameters:

action -

Throws:

E - the e

forEach

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

action -

Throws:

E - the e

forEachIndexed

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

Type Parameters:

E -

Parameters:

action -

Throws:

E - the e

forEachIndexed

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

action -

Throws:

E - the e

first

public u.OptionalDouble first()

Returns:

last

public u.OptionalDouble last()

Returns:

findFirst

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

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E - the e

findLast

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

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E - the e

findFirstIndex

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

Find first index.

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E - the e

findLastIndex

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

Find last index.

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E - the e

allMatch

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

Returns whether all elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

Throws:

E - the e

allMatch

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

Returns:

Throws:

E - the e

anyMatch

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

Returns whether any elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

Throws:

E - the e

anyMatch

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

Returns:

Throws:

E - the e

noneMatch

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

Returns whether no elements of this List match the provided predicate.

Type Parameters:

E -

Parameters:

filter -

Returns:

Throws:

E - the e

noneMatch

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

Returns:

Throws:

E - the e

count

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

Type Parameters:

E -

Parameters:

filter -

Returns:

Throws:

E - the e

count

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

Returns:

Throws:

E - the e

filter

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

Type Parameters:

E -

Parameters:

filter -

Returns:

a new List with the elements match the provided predicate.

Throws:

E - the e

filter

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

Returns:

Throws:

E - the e

filter

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

Type Parameters:

E -

Parameters:

filter -

max -

Returns:

a new List with the elements match the provided predicate.

Throws:

E - the e

filter

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

filter -

max -

Returns:

Throws:

E - the e

map

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

Type Parameters:

E -

Parameters:

mapper -

Returns:

Throws:

E - the e

map

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

Type Parameters:

E -

Parameters:

fromIndex -

toIndex -

mapper -

Returns:

Throws:

E - the e

mapToObj

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

Map to obj.

Type Parameters:

T -

E -

Parameters:

mapper -

Returns:

Throws:

E - the e

mapToObj

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

Map to obj.

Type Parameters:

T -

E -

Parameters:

fromIndex -

toIndex -

mapper -

Returns:

Throws:

E - the e

reduce

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

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

reduce

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

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

distinct

public DoubleList distinct(int fromIndex,
 int toIndex)

Specified by:

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

Parameters:

fromIndex -

toIndex -

Returns:

hasDuplicates

public boolean hasDuplicates()

Checks for duplicates.

Specified by:

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

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:

isSorted

public boolean isSorted()

Specified by:

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

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.

Specified by:

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

binarySearch

public int binarySearch(double valueToFind)

This List should be sorted first.

Parameters:

valueToFind -

Returns:

binarySearch

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

This List should be sorted first.

Parameters:

fromIndex -

toIndex -

valueToFind -

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:

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 fromIndex,
 int toIndex,
 int step)

Specified by:

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

Parameters:

fromIndex -

toIndex -

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>

Returns:

boxed

public List<Double> boxed()

Returns:

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>

Returns:

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:

iterator

public DoubleIterator iterator()

Returns:

stream

public DoubleStream stream()

Returns:

stream

public DoubleStream stream(int fromIndex,
 int toIndex)

Parameters:

fromIndex -

toIndex -

Returns:

apply

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

Specified by:

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

Type Parameters:

R -

E -

Parameters:

func -

Returns:

Throws:

E - the e

applyIfNotEmpty

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

Apply if not empty.

Specified by:

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

Type Parameters:

R -

E -

Parameters:

func -

Returns:

Throws:

E - the e

accept

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

Specified by:

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

Type Parameters:

E -

Parameters:

action -

Throws:

E - the e

acceptIfNotEmpty

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

Accept if not empty.

Specified by:

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

Type Parameters:

E -

Parameters:

action -

Returns:

Throws:

E - the e

hashCode

public int hashCode()

Overrides:

hashCode in class Object

Returns:

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

Parameters:

obj -

Returns:

toString

public String toString()

Overrides:

toString in class Object

Returns: