java.lang.Object
- org.eclipse.collections.impl.primitive.AbstractFloatIterable
- - org.eclipse.collections.impl.list.mutable.primitive.FloatArrayList

All Implemented Interfaces:

java.io.Externalizable, java.io.Serializable, MutableFloatCollection, FloatIterable, FloatList, MutableFloatList, OrderedFloatIterable, ReversibleFloatIterable, PrimitiveIterable
```
public class FloatArrayList
extends AbstractFloatIterable
implements MutableFloatList, java.io.Externalizable
```
FloatArrayList is similar to FastList, and is memory-optimized for float primitives. This file was automatically generated from template file primitiveArrayList.stg.

Since:

3.0.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private class FloatArrayList.InternalFloatIterator

Field Summary

Fields
Modifier and Type	Field	Description
`private static float[]`	`DEFAULT_SIZED_EMPTY_ARRAY`
`protected float[]`	`items`
`private static int`	`MAXIMUM_ARRAY_SIZE`
`private static long`	`serialVersionUID`
`protected int`	`size`
`private static float[]`	`ZERO_SIZED_ARRAY`

Constructor Summary

Constructors
Constructor Description

FloatArrayList()

FloatArrayList(float... array)

FloatArrayList(int initialCapacity)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`add(float newItem)`
`boolean`	`addAll(float... source)`
`boolean`	`addAll(FloatIterable source)`
`boolean`	`addAllAtIndex(int index, float... source)`
`boolean`	`addAllAtIndex(int index, FloatIterable source)`
`void`	`addAtIndex(int index, float element)`
`private void`	`addAtIndexLessThanSize(int index, float element)`
`boolean`	`allSatisfy(FloatPredicate predicate)`	Returns true if all of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
`boolean`	`anySatisfy(FloatPredicate predicate)`	Returns true if any of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
`void`	`appendString(java.lang.Appendable appendable, java.lang.String start, java.lang.String separator, java.lang.String end)`	Prints a string representation of this collection onto the given `Appendable`.
`LazyFloatIterable`	`asReversed()`
`MutableFloatList`	`asSynchronized()`
`MutableFloatList`	`asUnmodifiable()`
`int`	`binarySearch(float value)`
`MutableList<java.lang.Float>`	`boxed()`
`private void`	`checkEmpty()`
`RichIterable<FloatIterable>`	`chunk(int size)`	Partitions elements in fixed size chunks.
`void`	`clear()`
`<V> MutableList<V>`	`collect(FloatToObjectFunction<? extends V> function)`	Returns a new collection with the results of applying the specified function on each element of the source collection.
`<V,R extends java.util.Collection<V>> R`	`collect(FloatToObjectFunction<? extends V> function, R target)`	Same as `FloatIterable.collect(FloatToObjectFunction)` , only the results are added to the target Collection.
`boolean`	`contains(float value)`	Returns true if the value is contained in the FloatIterable, and false if it is not.
`private void`	`copyItems(int sourceSize, float[] source)`
`private float[]`	`copyItemsWithNewCapacity(int newCapacity)`
`int`	`count(FloatPredicate predicate)`	Returns a count of the number of elements in the FloatIterable that return true for the specified predicate.
`float`	`detectIfNone(FloatPredicate predicate, float ifNone)`
`MutableFloatList`	`distinct()`
`double`	`dotProduct(FloatList list)`
`void`	`each(FloatProcedure procedure)`	A synonym for forEach.
`void`	`ensureCapacity(int minCapacity)`
`private void`	`ensureCapacityForAdd()`
`boolean`	`equals(java.lang.Object otherList)`	Follows the same general contract as `List.equals(Object)`.
`MutableFloatIterator`	`floatIterator()`	Returns a primitive iterator that can be used to iterate over the FloatIterable in an imperative style.
`void`	`forEachWithIndex(FloatIntProcedure procedure)`
`float`	`get(int index)`
`float`	`getFirst()`
`float`	`getLast()`
`int`	`hashCode()`	Follows the same general contract as `List.hashCode()`.
`int`	`indexOf(float value)`
`<T> T`	`injectInto(T injectedValue, ObjectFloatToObjectFunction<? super T,? extends T> function)`
`<T> T`	`injectIntoWithIndex(T injectedValue, ObjectFloatIntToObjectFunction<? super T,? extends T> function)`
`int`	`lastIndexOf(float value)`
`float`	`max()`
`float`	`min()`
`FloatArrayList`	`newEmpty()`	Creates a new empty FloatArrayList.
`private java.lang.IndexOutOfBoundsException`	`newIndexOutOfBoundsException(int index)`
`static FloatArrayList`	`newList(FloatIterable source)`
`static FloatArrayList`	`newListWith(float... elements)`	Creates a new list using the passed `elements` argument as the backing store.
`static FloatArrayList`	`newWithNValues(int size, float value)`
`void`	`readExternal(java.io.ObjectInput in)`
`FloatArrayList`	`reject(FloatPredicate predicate)`	Returns a new FloatIterable with all of the elements in the FloatIterable that return false for the specified predicate.
`<R extends MutableFloatCollection> R`	`reject(FloatPredicate predicate, R target)`	Same as `FloatIterable.reject(FloatPredicate)` , only the results are added to the target MutableFloatCollection.
`boolean`	`remove(float value)`
`boolean`	`removeAll(float... source)`
`boolean`	`removeAll(FloatIterable source)`
`float`	`removeAtIndex(int index)`
`boolean`	`removeIf(FloatPredicate predicate)`
`boolean`	`retainAll(float... source)`
`boolean`	`retainAll(FloatIterable source)`
`FloatArrayList`	`reverseThis()`
`FloatArrayList`	`select(FloatPredicate predicate)`	Returns a new FloatIterable with all of the elements in the FloatIterable that return true for the specified predicate.
`<R extends MutableFloatCollection> R`	`select(FloatPredicate predicate, R target)`	Same as `FloatIterable.select(FloatPredicate)` , only the results are added to the target MutableFloatCollection.
`float`	`set(int index, float element)`
`private void`	`shiftElementsAtIndex(int index, int sourceSize)`
`int`	`size()`	Returns the number of items in this iterable.
`private int`	`sizePlusFiftyPercent(int oldSize)`
`FloatArrayList`	`sortThis()`	Sorts this list mutating its contents and returns the same mutable list (this).
`FloatArrayList`	`sortThis(FloatComparator comparator)`	Sorts the internal data structure of this list and returns the list itself as a convenience.
`MutableFloatList`	`subList(int fromIndex, int toIndex)`
`double`	`sum()`
`void`	`swap(int index1, int index2)`
`private void`	`throwOutOfBounds(int index)`
`float[]`	`toArray()`	Converts the FloatIterable to a primitive float array.
`float[]`	`toArray(float[] target)`	Converts the FloatIterable to a primitive float array.
`ImmutableFloatList`	`toImmutable()`	Returns an immutable copy of this list.
`FloatArrayList`	`toReversed()`
`MutableFloatStack`	`toStack()`	Converts the collection to a FloatStack.
`private void`	`transferItemsToNewArrayWithCapacity(int newCapacity)`
`void`	`trimToSize()`
`private void`	`wipeAndResetTheEnd(int newCurrentFilledIndex)`
`FloatArrayList`	`with(float element)`
`FloatArrayList`	`with(float element1, float element2)`
`FloatArrayList`	`with(float element1, float element2, float element3)`
`FloatArrayList`	`with(float element1, float element2, float element3, float... elements)`
`FloatArrayList`	`withAll(FloatIterable elements)`
`private FloatArrayList`	`withArrayCopy(float[] elements, int begin, int length)`
`FloatArrayList`	`without(float element)`
`FloatArrayList`	`withoutAll(FloatIterable elements)`
`static FloatArrayList`	`wrapCopy(float... array)`	Creates a new list by first copying the array passed in.
`void`	`writeExternal(java.io.ObjectOutput out)`
`<T> MutableList<FloatObjectPair<T>>`	`zip(java.lang.Iterable<T> iterable)`	Returns a `MutableList` formed from this `MutableFloatList` and a `ListIterable` by combining corresponding elements in pairs.
`MutableList<FloatFloatPair>`	`zipFloat(FloatIterable iterable)`	Returns a `MutableList` formed from this `MutableFloatList` and another `FloatList` by combining corresponding elements in pairs.

Methods inherited from class org.eclipse.collections.impl.primitive.AbstractFloatIterable
asLazy, average, maxIfEmpty, median, minIfEmpty, toBag, toList, toSet, toSortedArray, toSortedList, toString

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

Methods inherited from interface org.eclipse.collections.api.FloatIterable
asLazy, average, averageIfEmpty, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, containsAll, containsAll, containsAny, containsAny, containsNone, containsNone, flatCollect, forEach, injectIntoBoolean, injectIntoByte, injectIntoChar, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, injectIntoShort, maxIfEmpty, median, medianIfEmpty, minIfEmpty, noneSatisfy, reduce, reduceIfEmpty, summaryStatistics, toBag, toList, toSet, toSortedArray, toSortedList, toSortedList, toSortedListBy, toSortedListBy

Methods inherited from interface org.eclipse.collections.api.list.primitive.FloatList
forEachInBoth

Methods inherited from interface org.eclipse.collections.api.list.primitive.MutableFloatList
collectWithIndex, rejectWithIndex, selectWithIndex, shuffleThis, shuffleThis, sortThisBy, sortThisBy, tap

Methods inherited from interface org.eclipse.collections.api.ordered.primitive.OrderedFloatIterable
collectWithIndex, rejectWithIndex, selectWithIndex

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

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - DEFAULT_SIZED_EMPTY_ARRAY
```
private static final float[] DEFAULT_SIZED_EMPTY_ARRAY
```
  - ZERO_SIZED_ARRAY
```
private static final float[] ZERO_SIZED_ARRAY
```
  - MAXIMUM_ARRAY_SIZE
```
private static final int MAXIMUM_ARRAY_SIZE
```
    See Also:
    
    Constant Field Values
  - size
```
protected int size
```
  - items
```
protected transient float[] items
```
- Constructor Detail
  - FloatArrayList
```
public FloatArrayList()
```
  - FloatArrayList
```
public FloatArrayList(int initialCapacity)
```
  - FloatArrayList
```
public FloatArrayList(float... array)
```
- Method Detail
  - newListWith
```
public static FloatArrayList newListWith(float... elements)
```
    Creates a new list using the passed elements argument as the backing store.
    !!! WARNING: This method uses the passed in array, so can be very unsafe if the original array is held onto anywhere else. !!!
  - newList
```
public static FloatArrayList newList(FloatIterable source)
```
  - newWithNValues
```
public static FloatArrayList newWithNValues(int size,
                                            float value)
```
  - wrapCopy
```
public static FloatArrayList wrapCopy(float... array)
```
    Creates a new list by first copying the array passed in.
  - size
```
public int size()
```
    Description copied from interface: PrimitiveIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface PrimitiveIterable
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface MutableFloatCollection
  - contains
```
public boolean contains(float value)
```
    Description copied from interface: FloatIterable
    
    Returns true if the value is contained in the FloatIterable, and false if it is not.
    
    Specified by:
    
    contains in interface FloatIterable
  - get
```
public float get(int index)
```
    Specified by:
    
    get in interface FloatList
  - newIndexOutOfBoundsException
```
private java.lang.IndexOutOfBoundsException newIndexOutOfBoundsException(int index)
```
  - getFirst
```
public float getFirst()
```
    Specified by:
    
    getFirst in interface OrderedFloatIterable
  - getLast
```
public float getLast()
```
    Specified by:
    
    getLast in interface ReversibleFloatIterable
  - checkEmpty
```
private void checkEmpty()
```
  - indexOf
```
public int indexOf(float value)
```
    Specified by:
    
    indexOf in interface OrderedFloatIterable
  - lastIndexOf
```
public int lastIndexOf(float value)
```
    Specified by:
    
    lastIndexOf in interface FloatList
  - trimToSize
```
public void trimToSize()
```
  - transferItemsToNewArrayWithCapacity
```
private void transferItemsToNewArrayWithCapacity(int newCapacity)
```
  - copyItemsWithNewCapacity
```
private float[] copyItemsWithNewCapacity(int newCapacity)
```
  - sizePlusFiftyPercent
```
private int sizePlusFiftyPercent(int oldSize)
```
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
  - ensureCapacityForAdd
```
private void ensureCapacityForAdd()
```
  - add
```
public boolean add(float newItem)
```
    Specified by:
    
    add in interface MutableFloatCollection
  - addAll
```
public boolean addAll(float... source)
```
    Specified by:
    
    addAll in interface MutableFloatCollection
  - addAll
```
public boolean addAll(FloatIterable source)
```
    Specified by:
    
    addAll in interface MutableFloatCollection
  - copyItems
```
private void copyItems(int sourceSize,
                       float[] source)
```
  - throwOutOfBounds
```
private void throwOutOfBounds(int index)
```
  - addAtIndex
```
public void addAtIndex(int index,
                       float element)
```
    Specified by:
    
    addAtIndex in interface MutableFloatList
  - addAtIndexLessThanSize
```
private void addAtIndexLessThanSize(int index,
                                    float element)
```
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             float... source)
```
    Specified by:
    
    addAllAtIndex in interface MutableFloatList
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             FloatIterable source)
```
    Specified by:
    
    addAllAtIndex in interface MutableFloatList
  - shiftElementsAtIndex
```
private void shiftElementsAtIndex(int index,
                                  int sourceSize)
```
  - remove
```
public boolean remove(float value)
```
    Specified by:
    
    remove in interface MutableFloatCollection
  - removeIf
```
public boolean removeIf(FloatPredicate predicate)
```
    Specified by:
    
    removeIf in interface MutableFloatCollection
  - wipeAndResetTheEnd
```
private void wipeAndResetTheEnd(int newCurrentFilledIndex)
```
  - removeAll
```
public boolean removeAll(FloatIterable source)
```
    Specified by:
    
    removeAll in interface MutableFloatCollection
  - removeAll
```
public boolean removeAll(float... source)
```
    Specified by:
    
    removeAll in interface MutableFloatCollection
  - retainAll
```
public boolean retainAll(FloatIterable source)
```
    Specified by:
    
    retainAll in interface MutableFloatCollection
    
    See Also:
    
    Collection.retainAll(Collection)
  - retainAll
```
public boolean retainAll(float... source)
```
    Specified by:
    
    retainAll in interface MutableFloatCollection
    
    See Also:
    
    Collection.retainAll(Collection)
  - removeAtIndex
```
public float removeAtIndex(int index)
```
    Specified by:
    
    removeAtIndex in interface MutableFloatList
  - set
```
public float set(int index,
                 float element)
```
    Specified by:
    
    set in interface MutableFloatList
  - swap
```
public void swap(int index1,
                 int index2)
```
    Specified by:
    
    swap in interface MutableFloatList
  - with
```
public FloatArrayList with(float element)
```
    Specified by:
    
    with in interface MutableFloatCollection
    
    Specified by:
    
    with in interface MutableFloatList
  - without
```
public FloatArrayList without(float element)
```
    Specified by:
    
    without in interface MutableFloatCollection
    
    Specified by:
    
    without in interface MutableFloatList
  - withAll
```
public FloatArrayList withAll(FloatIterable elements)
```
    Specified by:
    
    withAll in interface MutableFloatCollection
    
    Specified by:
    
    withAll in interface MutableFloatList
  - withoutAll
```
public FloatArrayList withoutAll(FloatIterable elements)
```
    Specified by:
    
    withoutAll in interface MutableFloatCollection
    
    Specified by:
    
    withoutAll in interface MutableFloatList
  - with
```
public FloatArrayList with(float element1,
                           float element2)
```
  - with
```
public FloatArrayList with(float element1,
                           float element2,
                           float element3)
```
  - with
```
public FloatArrayList with(float element1,
                           float element2,
                           float element3,
                           float... elements)
```
  - withArrayCopy
```
private FloatArrayList withArrayCopy(float[] elements,
                                     int begin,
                                     int length)
```
  - floatIterator
```
public MutableFloatIterator floatIterator()
```
    Description copied from interface: FloatIterable
    
    Returns a primitive iterator that can be used to iterate over the FloatIterable in an imperative style.
    
    Specified by:
    
    floatIterator in interface FloatIterable
    
    Specified by:
    
    floatIterator in interface MutableFloatCollection
  - each
```
public void each(FloatProcedure procedure)
```
    Description copied from interface: FloatIterable
    
    A synonym for forEach.
    
    Specified by:
    
    each in interface FloatIterable
    
    Since:
    
    7.0.
  - forEachWithIndex
```
public void forEachWithIndex(FloatIntProcedure procedure)
```
    Specified by:
    
    forEachWithIndex in interface OrderedFloatIterable
  - injectInto
```
public <T> T injectInto(T injectedValue,
                        ObjectFloatToObjectFunction<? super T,? extends T> function)
```
    Specified by:
    
    injectInto in interface FloatIterable
  - injectIntoWithIndex
```
public <T> T injectIntoWithIndex(T injectedValue,
                                 ObjectFloatIntToObjectFunction<? super T,? extends T> function)
```
    Specified by:
    
    injectIntoWithIndex in interface OrderedFloatIterable
    
    Specified by:
    
    injectIntoWithIndex in interface ReversibleFloatIterable
  - chunk
```
public RichIterable<FloatIterable> chunk(int size)
```
    Description copied from interface: FloatIterable
    
    Partitions elements in fixed size chunks.
    
    Specified by:
    
    chunk in interface FloatIterable
    
    Parameters:
    
    size - the number of elements per chunk
    
    Returns:
    
    A RichIterable containing FloatIterables of size size, except the last will be truncated if the elements don't divide evenly.
  - count
```
public int count(FloatPredicate predicate)
```
    Description copied from interface: FloatIterable
    
    Returns a count of the number of elements in the FloatIterable that return true for the specified predicate.
    
    Specified by:
    
    count in interface FloatIterable
  - anySatisfy
```
public boolean anySatisfy(FloatPredicate predicate)
```
    Description copied from interface: FloatIterable
    
    Returns true if any of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
    
    Specified by:
    
    anySatisfy in interface FloatIterable
  - allSatisfy
```
public boolean allSatisfy(FloatPredicate predicate)
```
    Description copied from interface: FloatIterable
    
    Returns true if all of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
    
    Specified by:
    
    allSatisfy in interface FloatIterable
  - select
```
public FloatArrayList select(FloatPredicate predicate)
```
    Description copied from interface: FloatIterable
    
    Returns a new FloatIterable with all of the elements in the FloatIterable that return true for the specified predicate.
    
    Specified by:
    
    select in interface FloatIterable
    
    Specified by:
    
    select in interface FloatList
    
    Specified by:
    
    select in interface MutableFloatCollection
    
    Specified by:
    
    select in interface MutableFloatList
    
    Specified by:
    
    select in interface OrderedFloatIterable
    
    Specified by:
    
    select in interface ReversibleFloatIterable
  - select
```
public <R extends MutableFloatCollection> R select(FloatPredicate predicate,
                                                   R target)
```
    Description copied from interface: FloatIterable
    
    Same as FloatIterable.select(FloatPredicate) , only the results are added to the target MutableFloatCollection.
    
    Specified by:
    
    select in interface FloatIterable
    
    Since:
    
    8.1.
  - reject
```
public FloatArrayList reject(FloatPredicate predicate)
```
    Description copied from interface: FloatIterable
    
    Returns a new FloatIterable with all of the elements in the FloatIterable that return false for the specified predicate.
    
    Specified by:
    
    reject in interface FloatIterable
    
    Specified by:
    
    reject in interface FloatList
    
    Specified by:
    
    reject in interface MutableFloatCollection
    
    Specified by:
    
    reject in interface MutableFloatList
    
    Specified by:
    
    reject in interface OrderedFloatIterable
    
    Specified by:
    
    reject in interface ReversibleFloatIterable
  - reject
```
public <R extends MutableFloatCollection> R reject(FloatPredicate predicate,
                                                   R target)
```
    Description copied from interface: FloatIterable
    
    Same as FloatIterable.reject(FloatPredicate) , only the results are added to the target MutableFloatCollection.
    
    Specified by:
    
    reject in interface FloatIterable
    
    Since:
    
    8.1.
  - detectIfNone
```
public float detectIfNone(FloatPredicate predicate,
                          float ifNone)
```
    Specified by:
    
    detectIfNone in interface FloatIterable
  - collect
```
public <V> MutableList<V> collect(FloatToObjectFunction<? extends V> function)
```
    Description copied from interface: FloatIterable
    
    Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    
    Specified by:
    
    collect in interface FloatIterable
    
    Specified by:
    
    collect in interface FloatList
    
    Specified by:
    
    collect in interface MutableFloatCollection
    
    Specified by:
    
    collect in interface MutableFloatList
    
    Specified by:
    
    collect in interface OrderedFloatIterable
    
    Specified by:
    
    collect in interface ReversibleFloatIterable
  - collect
```
public <V,R extends java.util.Collection<V>> R collect(FloatToObjectFunction<? extends V> function,
                                                             R target)
```
    Description copied from interface: FloatIterable
    
    Same as FloatIterable.collect(FloatToObjectFunction) , only the results are added to the target Collection.
    
    Specified by:
    
    collect in interface FloatIterable
    
    Since:
    
    8.1.
  - max
```
public float max()
```
    Specified by:
    
    max in interface FloatIterable
  - min
```
public float min()
```
    Specified by:
    
    min in interface FloatIterable
  - sum
```
public double sum()
```
    Specified by:
    
    sum in interface FloatIterable
  - dotProduct
```
public double dotProduct(FloatList list)
```
    Specified by:
    
    dotProduct in interface FloatList
  - toArray
```
public float[] toArray()
```
    Description copied from interface: FloatIterable
    
    Converts the FloatIterable to a primitive float array.
    
    Specified by:
    
    toArray in interface FloatIterable
  - toArray
```
public float[] toArray(float[] target)
```
    Description copied from interface: FloatIterable
    
    Converts the FloatIterable to a primitive float array. If the collection fits into the provided array it is used to store its elements and is returned from the method, otherwise a new array of the appropriate size is allocated and returned. If the iterable is empty, the target array is returned unchanged.
    
    Specified by:
    
    toArray in interface FloatIterable
  - equals
```
public boolean equals(java.lang.Object otherList)
```
    Description copied from interface: FloatList
    
    Follows the same general contract as List.equals(Object).
    
    Specified by:
    
    equals in interface FloatList
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: FloatList
    
    Follows the same general contract as List.hashCode().
    
    Specified by:
    
    hashCode in interface FloatList
    
    Overrides:
    
    hashCode in class java.lang.Object
  - appendString
```
public void appendString(java.lang.Appendable appendable,
                         java.lang.String start,
                         java.lang.String separator,
                         java.lang.String end)
```
    Description copied from interface: PrimitiveIterable
    
    Prints a string representation of this collection onto the given Appendable. Prints the string returned by PrimitiveIterable.makeString(String, String, String).
    
    Specified by:
    
    appendString in interface PrimitiveIterable
  - asUnmodifiable
```
public MutableFloatList asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableFloatCollection
    
    Specified by:
    
    asUnmodifiable in interface MutableFloatList
  - asSynchronized
```
public MutableFloatList asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableFloatCollection
    
    Specified by:
    
    asSynchronized in interface MutableFloatList
  - toImmutable
```
public ImmutableFloatList toImmutable()
```
    Description copied from interface: MutableFloatList
    
    Returns an immutable copy of this list.
    
    Specified by:
    
    toImmutable in interface FloatList
    
    Specified by:
    
    toImmutable in interface MutableFloatCollection
    
    Specified by:
    
    toImmutable in interface MutableFloatList
  - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
    Specified by:
    
    writeExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
  - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException
```
    Specified by:
    
    readExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
  - asReversed
```
public LazyFloatIterable asReversed()
```
    Specified by:
    
    asReversed in interface ReversibleFloatIterable
  - reverseThis
```
public FloatArrayList reverseThis()
```
    Specified by:
    
    reverseThis in interface MutableFloatList
  - sortThis
```
public FloatArrayList sortThis()
```
    Description copied from interface: MutableFloatList
    
    Sorts this list mutating its contents and returns the same mutable list (this).
    
    Specified by:
    
    sortThis in interface MutableFloatList
  - sortThis
```
public FloatArrayList sortThis(FloatComparator comparator)
```
    Description copied from interface: MutableFloatList
    
    Sorts the internal data structure of this list and returns the list itself as a convenience.
    
    Specified by:
    
    sortThis in interface MutableFloatList
  - toReversed
```
public FloatArrayList toReversed()
```
    Specified by:
    
    toReversed in interface FloatList
    
    Specified by:
    
    toReversed in interface MutableFloatList
    
    Specified by:
    
    toReversed in interface ReversibleFloatIterable
  - binarySearch
```
public int binarySearch(float value)
```
    Specified by:
    
    binarySearch in interface FloatList
  - distinct
```
public MutableFloatList distinct()
```
    Specified by:
    
    distinct in interface FloatList
    
    Specified by:
    
    distinct in interface MutableFloatList
    
    Specified by:
    
    distinct in interface ReversibleFloatIterable
  - subList
```
public MutableFloatList subList(int fromIndex,
                                int toIndex)
```
    Specified by:
    
    subList in interface FloatList
    
    Specified by:
    
    subList in interface MutableFloatList
    
    See Also:
    
    List.subList(int fromIndex, int toIndex)
  - zipFloat
```
public MutableList<FloatFloatPair> zipFloat(FloatIterable iterable)
```
    Description copied from interface: MutableFloatList
    
    Returns a MutableList formed from this MutableFloatList and another FloatList by combining corresponding elements in pairs. If one of the two FloatLists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zipFloat in interface FloatList
    
    Specified by:
    
    zipFloat in interface MutableFloatList
    
    Since:
    
    9.1.
  - newEmpty
```
public FloatArrayList newEmpty()
```
    Creates a new empty FloatArrayList.
    
    Specified by:
    
    newEmpty in interface MutableFloatCollection
    
    Specified by:
    
    newEmpty in interface MutableFloatList
    
    Since:
    
    9.2.
  - zip
```
public <T> MutableList<FloatObjectPair<T>> zip(java.lang.Iterable<T> iterable)
```
    Description copied from interface: MutableFloatList
    
    Returns a MutableList formed from this MutableFloatList and a ListIterable by combining corresponding elements in pairs. If one of the two Lists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface FloatList
    
    Specified by:
    
    zip in interface MutableFloatList
    
    Since:
    
    9.1.
  - boxed
```
public MutableList<java.lang.Float> boxed()
```
    Specified by:
    
    boxed in interface MutableFloatList
  - toStack
```
public MutableFloatStack toStack()
```
    Description copied from interface: OrderedFloatIterable
    
    Converts the collection to a FloatStack.
    
    Specified by:
    
    toStack in interface OrderedFloatIterable

Constructor	Description
`FloatArrayList()`
`FloatArrayList(float... array)`
`FloatArrayList(int initialCapacity)`

Class FloatArrayList

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.primitive.AbstractFloatIterable

Methods inherited from class java.lang.Object

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

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

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

Methods inherited from interface org.eclipse.collections.api.ordered.primitive.OrderedFloatIterable

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

Field Detail

serialVersionUID

DEFAULT_SIZED_EMPTY_ARRAY

ZERO_SIZED_ARRAY

MAXIMUM_ARRAY_SIZE

size

items

Constructor Detail

FloatArrayList

FloatArrayList

FloatArrayList

Method Detail

newListWith

newList

newWithNValues

wrapCopy

size

clear

contains

get

newIndexOutOfBoundsException

getFirst

getLast

checkEmpty

indexOf

lastIndexOf

trimToSize

transferItemsToNewArrayWithCapacity

copyItemsWithNewCapacity

sizePlusFiftyPercent

ensureCapacity

ensureCapacityForAdd

add

addAll

addAll

copyItems

throwOutOfBounds

addAtIndex

addAtIndexLessThanSize

addAllAtIndex

addAllAtIndex

shiftElementsAtIndex

remove

removeIf

wipeAndResetTheEnd

removeAll

removeAll

retainAll

retainAll

removeAtIndex

set

swap

with

without

withAll

withoutAll

with

with

with

withArrayCopy

floatIterator

each

forEachWithIndex

injectInto

injectIntoWithIndex

chunk

count

anySatisfy