com.landawn.abacus.util

Class FloatList

java.lang.Object

com.landawn.abacus.util.PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

com.landawn.abacus.util.FloatList

All Implemented Interfaces:

java.io.Serializable, java.util.RandomAccess

public final class FloatList
extends PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Since:

0.8

Author:

Haiyang Li

See Also:

Serialized Form

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and Description
void	add(float e)
void	add(int index, float e)
boolean	addAll(float[] a)
boolean	addAll(FloatList c)
boolean	addAll(int index, float[] a)
boolean	addAll(int index, FloatList c)
boolean	allMatch(int fromIndex, int toIndex, FloatPredicate filter)
boolean	anyMatch(int fromIndex, int toIndex, FloatPredicate filter)
float[]	array() Returns the original element array without copying.
OptionalDouble	average()
OptionalDouble	average(int fromIndex, int toIndex)
int	binarySearch(float key) This List should be sorted first.
int	binarySearch(int fromIndex, int toIndex, float key) This List should be sorted first.
java.util.List<java.lang.Float>	boxed()
java.util.List<java.lang.Float>	boxed(int fromIndex, int toIndex)
void	clear()
boolean	contains(float e)
boolean	containsAll(float[] a)
boolean	containsAll(FloatList c)
boolean	containsAny(float[] a)
boolean	containsAny(FloatList c)
FloatList	copy()
FloatList	copy(int fromIndex, int toIndex)
FloatList	copy(int from, int to, int step)
int	count(int fromIndex, int toIndex, FloatPredicate filter)
float	delete(int index)
void	deleteAll(int... indices)
FloatList	difference(float[] a)
FloatList	difference(FloatList b)
boolean	disjoint(float[] b)
boolean	disjoint(FloatList c)
FloatList	distinct(int fromIndex, int toIndex)
boolean	equals(java.lang.Object obj)
void	fill(float val)
void	fill(int fromIndex, int toIndex, float val)
FloatList	filter(int fromIndex, int toIndex, FloatPredicate filter)
FloatList	filter(int fromIndex, int toIndex, FloatPredicate filter, int max)
OptionalFloat	findFirst(FloatPredicate predicate)
OptionalInt	findFirstIndex(FloatPredicate predicate)
OptionalFloat	findLast(FloatPredicate predicate)
OptionalInt	findLastIndex(FloatPredicate predicate)
OptionalFloat	first()
void	forEach(IndexedFloatConsumer action)
void	forEach(int fromIndex, int toIndex, FloatConsumer action)
void	forEach(int fromIndex, int toIndex, IndexedFloatConsumer action)
static FloatList	from(java.util.Collection<java.lang.Float> c)
static FloatList	from(java.util.Collection<java.lang.Float> c, float defaultValueForNull)
float	get(int index)
boolean	hasDuplicates()
int	hashCode()
int	indexOf(float e)
int	indexOf(int fromIndex, float e)
FloatList	intersection(float[] a)
FloatList	intersection(FloatList b)
boolean	isEmpty()
FloatIterator	iterator()
java.lang.String	join(int fromIndex, int toIndex, char delimiter)
java.lang.String	join(int fromIndex, int toIndex, java.lang.String delimiter)
OptionalFloat	kthLargest(int k)
OptionalFloat	kthLargest(int fromIndex, int toIndex, int k)
OptionalFloat	last()
int	lastIndexOf(float e)
int	lastIndexOf(int fromIndex, float e)
FloatList	map(FloatUnaryOperator mapper)
FloatList	map(int fromIndex, int toIndex, FloatUnaryOperator mapper)
<T> java.util.List<T>	mapToObj(FloatFunction<? extends T> mapper)
<T> java.util.List<T>	mapToObj(int fromIndex, int toIndex, FloatFunction<? extends T> mapper)
OptionalFloat	max()
OptionalFloat	max(int fromIndex, int toIndex)
OptionalFloat	median()
OptionalFloat	median(int fromIndex, int toIndex)
OptionalFloat	min()
OptionalFloat	min(int fromIndex, int toIndex)
boolean	noneMatch(int fromIndex, int toIndex, FloatPredicate filter)
int	occurrencesOf(float objectToFind)
static FloatList	of(float... a)
static FloatList	of(float[] a, int size)
void	parallelSort()
static FloatList	random(int len)
OptionalFloat	reduce(FloatBinaryOperator accumulator) This is equivalent to:
float	reduce(float identity, FloatBinaryOperator accumulator) This is equivalent to:
boolean	remove(float e)
boolean	removeAll(float[] a)
boolean	removeAll(FloatList c)
boolean	removeAllOccurrences(float e)
boolean	removeIf(FloatPredicate p)
static FloatList	repeat(float element, int len)
int	replaceAll(float oldVal, float newVal)
void	replaceAll(FloatUnaryOperator operator)
boolean	replaceIf(FloatPredicate predicate, float newValue)
boolean	retainAll(float[] a)
boolean	retainAll(FloatList c)
void	reverse()
void	reverse(int fromIndex, int toIndex)
void	reverseSort()
void	rotate(int distance)
float	set(int index, float e)
void	shuffle()
void	shuffle(java.util.Random rnd)
int	size()
void	sort()
java.util.List<FloatList>	split(int fromIndex, int toIndex, int size)
FloatStream	stream()
FloatStream	stream(int fromIndex, int toIndex)
float	sum()
float	sum(int fromIndex, int toIndex)
void	swap(int i, int j)
FloatList	symmetricDifference(float[] a)
FloatList	symmetricDifference(FloatList b)
DoubleList	toDoubleList()
<R extends java.util.List<java.lang.Float>> R	toList(int fromIndex, int toIndex, IntFunction<R> supplier)
<K,A,D> java.util.Map<K,D>	toMap(FloatFunction<? extends K> classifier, Collector<java.lang.Float,A,D> downstream)
<K,A,D,M extends java.util.Map<K,D>> M	toMap(FloatFunction<? extends K> classifier, Collector<java.lang.Float,A,D> downstream, Supplier<M> mapFactory)
<K,U> java.util.Map<K,U>	toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper)
<K,U> java.util.Map<K,U>	toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)
<K,U,M extends java.util.Map<K,U>> M	toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)
<K,U,M extends java.util.Map<K,U>> M	toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, Supplier<M> mapFactory)
Multiset<java.lang.Float>	toMultiset(int fromIndex, int toIndex, IntFunction<Multiset<java.lang.Float>> supplier)
FloatList	top(int n)
FloatList	top(int n, java.util.Comparator<? super java.lang.Float> cmp)
FloatList	top(int fromIndex, int toIndex, int n)
FloatList	top(int fromIndex, int toIndex, int n, java.util.Comparator<? super java.lang.Float> cmp)
<R extends java.util.Set<java.lang.Float>> R	toSet(int fromIndex, int toIndex, IntFunction<R> supplier)
java.lang.String	toString()
FloatList	trimToSize()

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

allMatch, anyMatch, count, distinct, filter, filter, forEach, join, join, join, join, noneMatch, println, split, toList, toList, toList, toMultiset, toMultiset, toMultiset, toSet, toSet, toSet

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

FloatList

public FloatList()

FloatList

public FloatList(int initialCapacity)

FloatList

public FloatList(float[] a)

The specified array is used as the element array for this list without copying action.

Parameters:

a -

FloatList

public FloatList(float[] a,
                 int size)

Method Detail

of

@SafeVarargs
public static FloatList of(float... a)

of

public static FloatList of(float[] a,
                           int size)

from

public static FloatList from(java.util.Collection<java.lang.Float> c)

from

public static FloatList from(java.util.Collection<java.lang.Float> c,
                             float defaultValueForNull)

repeat

public static FloatList repeat(float element,
                               int len)

random

public static FloatList random(int len)

array

public float[] array()

Returns the original element array without copying.

Returns:

get

public float get(int index)

set

public float set(int index,
                 float e)

Parameters:

index -

e -

Returns:

the old value in the specified position.

add

public void add(float e)

add

public void add(int index,
                float e)

addAll

public boolean addAll(FloatList c)

addAll

public boolean addAll(int index,
                      FloatList c)

addAll

public boolean addAll(float[] a)

Specified by:

addAll in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

addAll

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

Specified by:

addAll in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

remove

public boolean remove(float e)

Parameters:

e -

Returns:

true if this list contained the specified element

removeAllOccurrences

public boolean removeAllOccurrences(float e)

Parameters:

e -

Returns:

true if this list contained the specified element

removeAll

public boolean removeAll(FloatList c)

removeAll

public boolean removeAll(float[] a)

Specified by:

removeAll in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

removeIf

public boolean removeIf(FloatPredicate p)

Specified by:

removeIf in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

retainAll

public boolean retainAll(FloatList c)

retainAll

public boolean retainAll(float[] a)

delete

public float delete(int index)

Parameters:

index -

Returns:

the deleted element

deleteAll

public void deleteAll(int... indices)

Specified by:

deleteAll in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

replaceAll

public int replaceAll(float oldVal,
                      float newVal)

replaceAll

public void replaceAll(FloatUnaryOperator operator)

replaceIf

public boolean replaceIf(FloatPredicate predicate,
                         float newValue)

fill

public void fill(float val)

fill

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

contains

public boolean contains(float e)

containsAll

public boolean containsAll(FloatList c)

containsAll

public boolean containsAll(float[] a)

Specified by:

containsAll in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

containsAny

public boolean containsAny(FloatList c)

containsAny

public boolean containsAny(float[] a)

Specified by:

containsAny in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

disjoint

public boolean disjoint(FloatList c)

disjoint

public boolean disjoint(float[] b)

Specified by:

disjoint in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

intersection

public FloatList intersection(FloatList b)

Parameters:

b -

Returns:

See Also:

IntList.intersection(IntList)

intersection

public FloatList intersection(float[] a)

difference

public FloatList difference(FloatList b)

Parameters:

b -

Returns:

See Also:

IntList.difference(IntList)

difference

public FloatList difference(float[] a)

symmetricDifference

public FloatList symmetricDifference(FloatList b)

Parameters:

b -

Returns:

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

See Also:

IntList.symmetricDifference(IntList)

symmetricDifference

public FloatList symmetricDifference(float[] a)

occurrencesOf

public int occurrencesOf(float objectToFind)

indexOf

public int indexOf(float e)

indexOf

public int indexOf(int fromIndex,
                   float e)

lastIndexOf

public int lastIndexOf(float e)

lastIndexOf

public int lastIndexOf(int fromIndex,
                       float e)

Parameters:

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

e -

Returns:

min

public OptionalFloat min()

min

public OptionalFloat min(int fromIndex,
                         int toIndex)

median

public OptionalFloat median()

median

public OptionalFloat median(int fromIndex,
                            int toIndex)

max

public OptionalFloat max()

max

public OptionalFloat max(int fromIndex,
                         int toIndex)

kthLargest

public OptionalFloat kthLargest(int k)

kthLargest

public OptionalFloat kthLargest(int fromIndex,
                                int toIndex,
                                int k)

sum

public float sum()

sum

public float sum(int fromIndex,
                 int toIndex)

average

public OptionalDouble average()

average

public OptionalDouble average(int fromIndex,
                              int toIndex)

forEach

public void forEach(int fromIndex,
                    int toIndex,
                    FloatConsumer action)

Specified by:

forEach in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

forEach

public void forEach(IndexedFloatConsumer action)

forEach

public void forEach(int fromIndex,
                    int toIndex,
                    IndexedFloatConsumer action)

first

public OptionalFloat first()

last

public OptionalFloat last()

findFirst

public OptionalFloat findFirst(FloatPredicate predicate)

findLast

public OptionalFloat findLast(FloatPredicate predicate)

findFirstIndex

public OptionalInt findFirstIndex(FloatPredicate predicate)

findLastIndex

public OptionalInt findLastIndex(FloatPredicate predicate)

allMatch

public boolean allMatch(int fromIndex,
                        int toIndex,
                        FloatPredicate filter)

Specified by:

allMatch in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

anyMatch

public boolean anyMatch(int fromIndex,
                        int toIndex,
                        FloatPredicate filter)

Specified by:

anyMatch in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

noneMatch

public boolean noneMatch(int fromIndex,
                         int toIndex,
                         FloatPredicate filter)

Specified by:

noneMatch in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

hasDuplicates

public boolean hasDuplicates()

Specified by:

hasDuplicates in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

count

public int count(int fromIndex,
                 int toIndex,
                 FloatPredicate filter)

Specified by:

count in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

filter

public FloatList filter(int fromIndex,
                        int toIndex,
                        FloatPredicate filter)

Specified by:

filter in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

filter

public FloatList filter(int fromIndex,
                        int toIndex,
                        FloatPredicate filter,
                        int max)

Specified by:

filter in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

map

public FloatList map(FloatUnaryOperator mapper)

map

public FloatList map(int fromIndex,
                     int toIndex,
                     FloatUnaryOperator mapper)

mapToObj

public <T> java.util.List<T> mapToObj(FloatFunction<? extends T> mapper)

mapToObj

public <T> java.util.List<T> mapToObj(int fromIndex,
                                      int toIndex,
                                      FloatFunction<? extends T> mapper)

reduce

public OptionalFloat reduce(FloatBinaryOperator accumulator)

This is equivalent to:

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

    float result = elementData[0];

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

    return OptionalFloat.of(result);
 
 

Parameters:

accumulator -

Returns:

reduce

public float reduce(float identity,
                    FloatBinaryOperator accumulator)

This is equivalent to:

 
     if (isEmpty()) {
         return identity;
     }
 
     float result = identity;
 
     for (int i = 0; i < size; i++) {
         result = accumulator.applyAsFloat(result, elementData[i]);
    }
 
     return result;
 
 

Parameters:

identity -

accumulator -

Returns:

distinct

public FloatList distinct(int fromIndex,
                          int toIndex)

Specified by:

distinct in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

top

public FloatList top(int n)

top

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

top

public FloatList top(int n,
                     java.util.Comparator<? super java.lang.Float> cmp)

top

public FloatList top(int fromIndex,
                     int toIndex,
                     int n,
                     java.util.Comparator<? super java.lang.Float> cmp)

sort

public void sort()

Specified by:

sort in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

parallelSort

public void parallelSort()

reverseSort

public void reverseSort()

binarySearch

public int binarySearch(float key)

This List should be sorted first.

Parameters:

key -

Returns:

binarySearch

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

This List should be sorted first.

Parameters:

fromIndex -

toIndex -

key -

Returns:

reverse

public void reverse()

Specified by:

reverse in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

reverse

public void reverse(int fromIndex,
                    int toIndex)

Specified by:

reverse in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

rotate

public void rotate(int distance)

Specified by:

rotate in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

shuffle

public void shuffle()

Specified by:

shuffle in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

shuffle

public void shuffle(java.util.Random rnd)

Specified by:

shuffle in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

swap

public void swap(int i,
                 int j)

Specified by:

swap in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

copy

public FloatList copy()

Specified by:

copy in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

a copy of this List

copy

public FloatList copy(int fromIndex,
                      int toIndex)

Specified by:

copy in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

copy

public FloatList copy(int from,
                      int to,
                      int step)

Specified by:

copy in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Parameters:

from -

to -

step -

Returns:

See Also:

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

split

public java.util.List<FloatList> split(int fromIndex,
                                       int toIndex,
                                       int size)

Specified by:

split in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

join

public java.lang.String join(int fromIndex,
                             int toIndex,
                             char delimiter)

Specified by:

join in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

join

public java.lang.String join(int fromIndex,
                             int toIndex,
                             java.lang.String delimiter)

Specified by:

join in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

trimToSize

public FloatList trimToSize()

Specified by:

trimToSize in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

Returns:

this List with trailing unused space removed.

clear

public void clear()

Specified by:

clear in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

size

public int size()

Specified by:

size in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

boxed

public java.util.List<java.lang.Float> boxed()

boxed

public java.util.List<java.lang.Float> boxed(int fromIndex,
                                             int toIndex)

toDoubleList

public DoubleList toDoubleList()

toList

public <R extends java.util.List<java.lang.Float>> R toList(int fromIndex,
                                                            int toIndex,
                                                            IntFunction<R> supplier)

Specified by:

toList in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

toSet

public <R extends java.util.Set<java.lang.Float>> R toSet(int fromIndex,
                                                          int toIndex,
                                                          IntFunction<R> supplier)

Specified by:

toSet in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

toMultiset

public Multiset<java.lang.Float> toMultiset(int fromIndex,
                                            int toIndex,
                                            IntFunction<Multiset<java.lang.Float>> supplier)

Specified by:

toMultiset in class PrimitiveList<FloatConsumer,FloatPredicate,java.lang.Float,float[],FloatList>

toMap

public <K,U> java.util.Map<K,U> toMap(FloatFunction<? extends K> keyExtractor,
                                      FloatFunction<? extends U> valueMapper)

toMap

public <K,U,M extends java.util.Map<K,U>> M toMap(FloatFunction<? extends K> keyExtractor,
                                                  FloatFunction<? extends U> valueMapper,
                                                  Supplier<M> mapFactory)

toMap

public <K,U> java.util.Map<K,U> toMap(FloatFunction<? extends K> keyExtractor,
                                      FloatFunction<? extends U> valueMapper,
                                      BinaryOperator<U> mergeFunction)

toMap

public <K,U,M extends java.util.Map<K,U>> M toMap(FloatFunction<? extends K> keyExtractor,
                                                  FloatFunction<? extends U> valueMapper,
                                                  BinaryOperator<U> mergeFunction,
                                                  Supplier<M> mapFactory)

toMap

public <K,A,D> java.util.Map<K,D> toMap(FloatFunction<? extends K> classifier,
                                        Collector<java.lang.Float,A,D> downstream)

toMap

public <K,A,D,M extends java.util.Map<K,D>> M toMap(FloatFunction<? extends K> classifier,
                                                    Collector<java.lang.Float,A,D> downstream,
                                                    Supplier<M> mapFactory)

iterator

public FloatIterator iterator()

stream

public FloatStream stream()

stream

public FloatStream stream(int fromIndex,
                          int toIndex)

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object