Interface FloatIterable

    • 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.
      • toArray

        default float[] toArray​(float[] target)
        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.
      • contains

        boolean contains​(float value)
        Returns true if the value is contained in the FloatIterable, and false if it is not.
      • containsAll

        default boolean containsAll​(float... source)
        Returns true if all of the values specified in the source array are contained in the FloatIterable, and false if they are not.
      • containsAll

        default boolean containsAll​(FloatIterable source)
        Returns true if all of the values specified in the source FloatIterable are contained in the FloatIterable, and false if they are not.
      • containsAny

        default boolean containsAny​(float... source)
        Returns true if any of the values specified in the source array are contained in the FloatIterable, and false if they are not.
        Since:
        11.0
      • containsAny

        default boolean containsAny​(FloatIterable source)
        Returns true if any of the values specified in the source FloatIterable are contained in the FloatIterable, and false if they are not.
        Since:
        11.0
      • containsNone

        default boolean containsNone​(float... source)
        Returns true if none of the values specified in the source array are contained in the FloatIterable, and false if they are.
        Since:
        11.0
      • containsNone

        default boolean containsNone​(FloatIterable source)
        Returns true if none of the values specified in the source FloatIterable are contained in the FloatIterable, and false if they are.
        Since:
        11.0
      • forEach

        default 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.
      • 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.
      • 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.
      • 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

        default 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.
      • injectIntoBoolean

        default boolean injectIntoBoolean​(boolean injectedValue,
                                          BooleanFloatToBooleanFunction function)
        Returns the final boolean result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoByte

        default byte injectIntoByte​(byte injectedValue,
                                    ByteFloatToByteFunction function)
        Returns the final byte result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoChar

        default char injectIntoChar​(char injectedValue,
                                    CharFloatToCharFunction function)
        Returns the final char result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoShort

        default short injectIntoShort​(short injectedValue,
                                      ShortFloatToShortFunction function)
        Returns the final short result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoInt

        default int injectIntoInt​(int injectedValue,
                                  IntFloatToIntFunction function)
        Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoFloat

        default float injectIntoFloat​(float injectedValue,
                                      FloatFloatToFloatFunction function)
        Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoLong

        default long injectIntoLong​(long injectedValue,
                                    LongFloatToLongFunction function)
        Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • injectIntoDouble

        default double injectIntoDouble​(double injectedValue,
                                        DoubleFloatToDoubleFunction function)
        Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Since:
        11.1
      • chunk

        default RichIterable<FloatIterable> chunk​(int size)
        Partitions elements in fixed size chunks.
        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.
        Since:
        9.2
      • 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

        default MutableFloatList toSortedList​(FloatComparator comparator)
        Converts the collection to a MutableFloatList implementation sorted using the provided comparator.
      • toSortedListBy

        default <T> MutableFloatList toSortedListBy​(FloatToObjectFunction<T> function)
        Converts the collection to a MutableFloatListImplementation sorted based on the natural order of the key returned by function.
      • toSortedListBy

        default <T> MutableFloatList toSortedListBy​(FloatToObjectFunction<T> function,
                                                    java.util.Comparator<? super T> comparator)
        Converts the collection to a MutableFloatList implementation, which is sorted based on the key returned by function using the provided comparator.