FloatIterable (Eclipse Collections

All Superinterfaces:

PrimitiveIterable

All Known Subinterfaces:

ByteFloatMap, CharFloatMap, DoubleFloatMap, FloatBag, FloatFloatMap, FloatList, FloatSet, FloatStack, FloatValuesMap, ImmutableByteFloatMap, ImmutableCharFloatMap, ImmutableDoubleFloatMap, ImmutableFloatBag, ImmutableFloatCollection, ImmutableFloatFloatMap, ImmutableFloatList, ImmutableFloatSet, ImmutableFloatStack, ImmutableIntFloatMap, ImmutableLongFloatMap, ImmutableObjectFloatMap<K>, ImmutableShortFloatMap, IntFloatMap, LazyFloatIterable, LongFloatMap, MutableByteFloatMap, MutableCharFloatMap, MutableDoubleFloatMap, MutableFloatBag, MutableFloatCollection, MutableFloatFloatMap, MutableFloatList, MutableFloatSet, MutableFloatStack, MutableFloatValuesMap, MutableIntFloatMap, MutableLongFloatMap, MutableObjectFloatMap<K>, MutableShortFloatMap, ObjectFloatMap<K>, OrderedFloatIterable, ReversibleFloatIterable, ShortFloatMap

All Known Implementing Classes:

AbstractFloatIterable, AbstractFloatSet, AbstractFloatStack, AbstractImmutableFloatSet, AbstractImmutableObjectFloatMap, AbstractLazyFloatIterable, AbstractMutableFloatKeySet, AbstractMutableFloatValuesMap, AbstractSynchronizedFloatCollection, AbstractUnmodifiableFloatCollection, ByteFloatHashMap, CharFloatHashMap, CollectBooleanToFloatIterable, CollectByteToFloatIterable, CollectCharToFloatIterable, CollectDoubleToFloatIterable, CollectFloatIterable, CollectFloatToFloatIterable, CollectIntToFloatIterable, CollectLongToFloatIterable, CollectShortToFloatIterable, DoubleFloatHashMap, FloatArrayList, FloatArrayStack, FloatFloatHashMap, FloatHashBag, FloatHashSet, IntFloatHashMap, LazyFloatIterableAdapter, LongFloatHashMap, ObjectFloatHashMap, ObjectFloatHashMapWithHashingStrategy, ReverseFloatIterable, SelectFloatIterable, ShortFloatHashMap, SynchronizedByteFloatMap, SynchronizedCharFloatMap, SynchronizedDoubleFloatMap, SynchronizedFloatBag, SynchronizedFloatCollection, SynchronizedFloatFloatMap, SynchronizedFloatIterable, SynchronizedFloatList, SynchronizedFloatSet, SynchronizedFloatStack, SynchronizedIntFloatMap, SynchronizedLongFloatMap, SynchronizedObjectFloatMap, SynchronizedShortFloatMap, TapFloatIterable, UnmodifiableByteFloatMap, UnmodifiableCharFloatMap, UnmodifiableDoubleFloatMap, UnmodifiableFloatBag, UnmodifiableFloatCollection, UnmodifiableFloatFloatMap, UnmodifiableFloatList, UnmodifiableFloatSet, UnmodifiableFloatStack, UnmodifiableIntFloatMap, UnmodifiableLongFloatMap, UnmodifiableObjectFloatMap, UnmodifiableShortFloatMap
```
public interface FloatIterable
extends PrimitiveIterable
```
FloatIterable is an interface which is memory-optimized for float primitives. It is inspired by the interface RichIterable, and contains a subset of the internal iterator methods on RichIterable like collect, sum, etc. The API also includes an external iterator method, which returns an FloatIterator. FloatIterator helps iterate over the FloatIterable without boxing the primitives. This file was automatically generated from template file primitiveIterable.stg.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`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.
`LazyFloatIterable`	`asLazy()`	Returns a LazyFloatIterable adapter wrapping the source FloatIterable.
`double`	`average()`
`default double`	`averageIfEmpty(double defaultValue)`
`<V> RichIterable<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.
`default <V,R extends java.util.Collection<V>> R`	`collect(FloatToObjectFunction<? extends V> function, R target)`	Same as `collect(FloatToObjectFunction)` , only the results are added to the target Collection.
`default <R extends MutableBooleanCollection> R`	`collectBoolean(FloatToBooleanFunction function, R target)`	Returns the target `MutableBooleanCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableByteCollection> R`	`collectByte(FloatToByteFunction function, R target)`	Returns the target `MutableByteCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableCharCollection> R`	`collectChar(FloatToCharFunction function, R target)`	Returns the target `MutableCharCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableDoubleCollection> R`	`collectDouble(FloatToDoubleFunction function, R target)`	Returns the target `MutableDoubleCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableFloatCollection> R`	`collectFloat(FloatToFloatFunction function, R target)`	Returns the target `MutableFloatCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableIntCollection> R`	`collectInt(FloatToIntFunction function, R target)`	Returns the target `MutableIntCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableLongCollection> R`	`collectLong(FloatToLongFunction function, R target)`	Returns the target `MutableLongCollection` with the results of applying the specified function on each element of the source collection.
`default <R extends MutableShortCollection> R`	`collectShort(FloatToShortFunction function, R target)`	Returns the target `MutableShortCollection` with the results of applying the specified function on each element of the source collection.
`boolean`	`contains(float value)`	Returns true if the value is contained in the FloatIterable, and false if it is not.
`boolean`	`containsAll(float... source)`	Returns true if the all of the values specified in the source array are contained in the FloatIterable, and false if they are not.
`boolean`	`containsAll(FloatIterable source)`	Returns true if the all of the values specified in the source FloatIterable are contained in the FloatIterable, and false if they are not.
`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)`
`void`	`each(FloatProcedure procedure)`	A synonym for forEach.
`default <V,R extends java.util.Collection<V>> R`	`flatCollect(FloatToObjectFunction<? extends java.lang.Iterable<V>> function, R target)`	`flatCollect` is a special case of `collect(FloatToObjectFunction)`.
`FloatIterator`	`floatIterator()`	Returns a primitive iterator that can be used to iterate over the FloatIterable in an imperative style.
`void`	`forEach(FloatProcedure procedure)`	Applies the FloatProcedure to each element in the FloatIterable.
`<T> T`	`injectInto(T injectedValue, ObjectFloatToObjectFunction<? super T,? extends T> function)`
`float`	`max()`
`float`	`maxIfEmpty(float defaultValue)`
`double`	`median()`
`default double`	`medianIfEmpty(double defaultValue)`
`float`	`min()`
`float`	`minIfEmpty(float defaultValue)`
`boolean`	`noneSatisfy(FloatPredicate predicate)`	Returns true if none of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
`FloatIterable`	`reject(FloatPredicate predicate)`	Returns a new FloatIterable with all of the elements in the FloatIterable that return false for the specified predicate.
`default <R extends MutableFloatCollection> R`	`reject(FloatPredicate predicate, R target)`	Same as `reject(FloatPredicate)` , only the results are added to the target MutableFloatCollection.
`FloatIterable`	`select(FloatPredicate predicate)`	Returns a new FloatIterable with all of the elements in the FloatIterable that return true for the specified predicate.
`default <R extends MutableFloatCollection> R`	`select(FloatPredicate predicate, R target)`	Same as `select(FloatPredicate)` , only the results are added to the target MutableFloatCollection.
`double`	`sum()`
`default java.util.DoubleSummaryStatistics`	`summaryStatistics()`
`default FloatIterable`	`tap(FloatProcedure procedure)`
`float[]`	`toArray()`	Converts the FloatIterable to a primitive float array.
`MutableFloatBag`	`toBag()`	Converts the FloatIterable to a new MutableFloatBag.
`MutableFloatList`	`toList()`	Converts the FloatIterable to a new MutableFloatList.
`MutableFloatSet`	`toSet()`	Converts the FloatIterable to a new MutableFloatSet.
`float[]`	`toSortedArray()`
`MutableFloatList`	`toSortedList()`

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

- Method Detail
  - floatIterator
```
FloatIterator floatIterator()
```
    Returns a primitive iterator that can be used to iterate over the FloatIterable in an imperative style.
  - toArray
```
float[] toArray()
```
    Converts the FloatIterable to a primitive float array.
  - contains
```
boolean contains(float value)
```
    Returns true if the value is contained in the FloatIterable, and false if it is not.
  - containsAll
```
boolean containsAll(float... source)
```
    Returns true if the all of the values specified in the source array are contained in the FloatIterable, and false if they are not.
  - containsAll
```
boolean containsAll(FloatIterable source)
```
    Returns true if the all of the values specified in the source FloatIterable are contained in the FloatIterable, and false if they are not.
  - forEach
```
void forEach(FloatProcedure procedure)
```
    Applies the FloatProcedure to each element in the FloatIterable.
  - each
```
void each(FloatProcedure procedure)
```
    A synonym for forEach.
    
    Since:
    
    7.0.
  - tap
```
default FloatIterable tap(FloatProcedure procedure)
```
    Since:
    
    9.0.
  - select
```
FloatIterable select(FloatPredicate predicate)
```
    Returns a new FloatIterable with all of the elements in the FloatIterable that return true for the specified predicate.
  - reject
```
FloatIterable reject(FloatPredicate predicate)
```
    Returns a new FloatIterable with all of the elements in the FloatIterable that return false for the specified predicate.
  - select
```
default <R extends MutableFloatCollection> R select(FloatPredicate predicate,
                                                    R target)
```
    Same as select(FloatPredicate) , only the results are added to the target MutableFloatCollection.
    
    Since:
    
    8.1.
  - reject
```
default <R extends MutableFloatCollection> R reject(FloatPredicate predicate,
                                                    R target)
```
    Same as reject(FloatPredicate) , only the results are added to the target MutableFloatCollection.
    
    Since:
    
    8.1.
  - collect
```
<V> RichIterable<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. This method is also commonly called transform or map.
  - collect
```
default <V,R extends java.util.Collection<V>> R collect(FloatToObjectFunction<? extends V> function,
                                                        R target)
```
    Same as collect(FloatToObjectFunction) , only the results are added to the target Collection.
    
    Since:
    
    8.1.
  - flatCollect
```
default <V,R extends java.util.Collection<V>> R flatCollect(FloatToObjectFunction<? extends java.lang.Iterable<V>> function,
                                                            R target)
```
    flatCollect is a special case of collect(FloatToObjectFunction). With collect, when the FloatToObjectFunction returns a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection instead. This method is commonly called flatMap.
    
    Since:
    
    8.1.
  - collectBoolean
```
default <R extends MutableBooleanCollection> R collectBoolean(FloatToBooleanFunction function,
                                                              R target)
```
    Returns the target MutableBooleanCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectByte
```
default <R extends MutableByteCollection> R collectByte(FloatToByteFunction function,
                                                        R target)
```
    Returns the target MutableByteCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectChar
```
default <R extends MutableCharCollection> R collectChar(FloatToCharFunction function,
                                                        R target)
```
    Returns the target MutableCharCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectShort
```
default <R extends MutableShortCollection> R collectShort(FloatToShortFunction function,
                                                          R target)
```
    Returns the target MutableShortCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectInt
```
default <R extends MutableIntCollection> R collectInt(FloatToIntFunction function,
                                                      R target)
```
    Returns the target MutableIntCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectFloat
```
default <R extends MutableFloatCollection> R collectFloat(FloatToFloatFunction function,
                                                          R target)
```
    Returns the target MutableFloatCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectLong
```
default <R extends MutableLongCollection> R collectLong(FloatToLongFunction function,
                                                        R target)
```
    Returns the target MutableLongCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - collectDouble
```
default <R extends MutableDoubleCollection> R collectDouble(FloatToDoubleFunction function,
                                                            R target)
```
    Returns the target MutableDoubleCollection with the results of applying the specified function on each element of the source collection.
    
    Since:
    
    8.1.
  - detectIfNone
```
float detectIfNone(FloatPredicate predicate,
                   float ifNone)
```
  - count
```
int count(FloatPredicate predicate)
```
    Returns a count of the number of elements in the FloatIterable that return true for the specified predicate.
  - anySatisfy
```
boolean anySatisfy(FloatPredicate predicate)
```
    Returns true if any of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
  - allSatisfy
```
boolean allSatisfy(FloatPredicate predicate)
```
    Returns true if all of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
  - noneSatisfy
```
boolean noneSatisfy(FloatPredicate predicate)
```
    Returns true if none of the elements in the FloatIterable return true for the specified predicate, otherwise returns false.
  - toList
```
MutableFloatList toList()
```
    Converts the FloatIterable to a new MutableFloatList.
  - toSet
```
MutableFloatSet toSet()
```
    Converts the FloatIterable to a new MutableFloatSet.
  - toBag
```
MutableFloatBag toBag()
```
    Converts the FloatIterable to a new MutableFloatBag.
  - asLazy
```
LazyFloatIterable asLazy()
```
    Returns a LazyFloatIterable adapter wrapping the source FloatIterable.
  - injectInto
```
<T> T injectInto(T injectedValue,
                 ObjectFloatToObjectFunction<? super T,? extends T> function)
```
  - sum
```
double sum()
```
  - summaryStatistics
```
default java.util.DoubleSummaryStatistics summaryStatistics()
```
    Since:
    
    8.0
  - max
```
float max()
```
  - maxIfEmpty
```
float maxIfEmpty(float defaultValue)
```
  - min
```
float min()
```
  - minIfEmpty
```
float minIfEmpty(float defaultValue)
```
  - average
```
double average()
```
  - averageIfEmpty
```
default double averageIfEmpty(double defaultValue)
```
    Since:
    
    9.0
  - median
```
double median()
```
  - medianIfEmpty
```
default double medianIfEmpty(double defaultValue)
```
    Since:
    
    9.0
  - toSortedArray
```
float[] toSortedArray()
```
  - toSortedList
```
MutableFloatList toSortedList()
```

Interface FloatIterable

Method Summary

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

Method Detail

floatIterator

toArray

contains

containsAll

containsAll

forEach

each

tap

select

reject

select

reject

collect

collect

flatCollect

collectBoolean

collectByte

collectChar

collectShort

collectInt

collectFloat

collectLong

collectDouble

detectIfNone

count

anySatisfy

allSatisfy

noneSatisfy

toList

toSet

toBag

asLazy

injectInto

sum

summaryStatistics

max

maxIfEmpty

min

minIfEmpty

average

averageIfEmpty

median

medianIfEmpty

toSortedArray

toSortedList