Package org.eclipse.collections.api

Interface ByteIterable

All Superinterfaces:
PrimitiveIterable
All Known Subinterfaces:
ByteBag, ByteByteMap, ByteList, ByteSet, ByteStack, ByteValuesMap, CharByteMap, DoubleByteMap, FloatByteMap, ImmutableByteBag, ImmutableByteByteMap, ImmutableByteCollection, ImmutableByteList, ImmutableByteSet, ImmutableByteStack, ImmutableCharByteMap, ImmutableDoubleByteMap, ImmutableFloatByteMap, ImmutableIntByteMap, ImmutableLongByteMap, ImmutableObjectByteMap<K>, ImmutableShortByteMap, IntByteMap, LazyByteIterable, LongByteMap, MutableByteBag, MutableByteByteMap, MutableByteCollection, MutableByteList, MutableByteSet, MutableByteStack, MutableByteValuesMap, MutableCharByteMap, MutableDoubleByteMap, MutableFloatByteMap, MutableIntByteMap, MutableLongByteMap, MutableObjectByteMap<K>, MutableShortByteMap, ObjectByteMap<K>, OrderedByteIterable, ReversibleByteIterable, ShortByteMap
All Known Implementing Classes:
AbstractByteIterable, AbstractByteSet, AbstractByteStack, AbstractImmutableByteSet, AbstractImmutableObjectByteMap, AbstractLazyByteIterable, AbstractMutableByteKeySet, AbstractMutableByteValuesMap, AbstractSynchronizedByteCollection, AbstractUnmodifiableByteCollection, ByteArrayList, ByteArrayStack, ByteByteHashMap, ByteHashBag, ByteHashSet, CharByteHashMap, CollectBooleanToByteIterable, CollectByteIterable, CollectByteToByteIterable, CollectCharToByteIterable, CollectDoubleToByteIterable, CollectFloatToByteIterable, CollectIntToByteIterable, CollectLongToByteIterable, CollectShortToByteIterable, DoubleByteHashMap, FloatByteHashMap, IntByteHashMap, LazyByteIterableAdapter, LongByteHashMap, ObjectByteHashMap, ObjectByteHashMapWithHashingStrategy, ReverseByteIterable, SelectByteIterable, ShortByteHashMap, SynchronizedByteBag, SynchronizedByteByteMap, SynchronizedByteCollection, SynchronizedByteIterable, SynchronizedByteList, SynchronizedByteSet, SynchronizedByteStack, SynchronizedCharByteMap, SynchronizedDoubleByteMap, SynchronizedFloatByteMap, SynchronizedIntByteMap, SynchronizedLongByteMap, SynchronizedObjectByteMap, SynchronizedShortByteMap, TapByteIterable, UnmodifiableByteBag, UnmodifiableByteByteMap, UnmodifiableByteCollection, UnmodifiableByteList, UnmodifiableByteSet, UnmodifiableByteStack, UnmodifiableCharByteMap, UnmodifiableDoubleByteMap, UnmodifiableFloatByteMap, UnmodifiableIntByteMap, UnmodifiableLongByteMap, UnmodifiableObjectByteMap, UnmodifiableShortByteMap
public interface ByteIterable
extends PrimitiveIterable
ByteIterable is an interface which is memory-optimized for byte 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 ByteIterator. ByteIterator helps iterate over the ByteIterable without boxing the primitives. This file was automatically generated from template file primitiveIterable.stg.

  • Method Details

    • byteIterator

      ByteIterator byteIterator()
      Returns a primitive iterator that can be used to iterate over the ByteIterable in an imperative style.

    • toArray

      byte[] toArray()
      Converts the ByteIterable to a primitive byte array.

    • toArray

      default byte[] toArray​(byte[] target)
      Converts the ByteIterable to a primitive byte 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​(byte value)
      Returns true if the value is contained in the ByteIterable, and false if it is not.

    • containsAll

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

    • containsAll

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

    • forEach

      void forEach​(ByteProcedure procedure)
      Applies the ByteProcedure to each element in the ByteIterable.

    • each

      void each​(ByteProcedure procedure)
      A synonym for forEach.
      Since:
      7.0.

    • tap

      default ByteIterable tap​(ByteProcedure procedure)
      Since:
      9.0.

    • select

      ByteIterable select​(BytePredicate predicate)
      Returns a new ByteIterable with all of the elements in the ByteIterable that return true for the specified predicate.

    • reject

      ByteIterable reject​(BytePredicate predicate)
      Returns a new ByteIterable with all of the elements in the ByteIterable that return false for the specified predicate.

    • select

      default <R extends MutableByteCollection> R select​(BytePredicate predicate, R target)
      Same as select(BytePredicate) , only the results are added to the target MutableByteCollection.
      Since:
      8.1.

    • reject

      default <R extends MutableByteCollection> R reject​(BytePredicate predicate, R target)
      Same as reject(BytePredicate) , only the results are added to the target MutableByteCollection.
      Since:
      8.1.

    • collect

      <V> RichIterable<V> collect​(ByteToObjectFunction<? 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 Collection<V>> R collect​(ByteToObjectFunction<? extends V> function, R target)
      Same as collect(ByteToObjectFunction) , only the results are added to the target Collection.
      Since:
      8.1.

    • flatCollect

      default <V,​ R extends Collection<V>> R flatCollect​(ByteToObjectFunction<? extends Iterable<V>> function, R target)
      flatCollect is a special case of collect(ByteToObjectFunction). With collect, when the ByteToObjectFunction 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​(ByteToBooleanFunction 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​(ByteToByteFunction 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​(ByteToCharFunction 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​(ByteToShortFunction 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​(ByteToIntFunction 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​(ByteToFloatFunction 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​(ByteToLongFunction 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​(ByteToDoubleFunction 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

      byte detectIfNone​(BytePredicate predicate, byte ifNone)

    • count

      int count​(BytePredicate predicate)
      Returns a count of the number of elements in the ByteIterable that return true for the specified predicate.

    • anySatisfy

      boolean anySatisfy​(BytePredicate predicate)
      Returns true if any of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.

    • allSatisfy

      boolean allSatisfy​(BytePredicate predicate)
      Returns true if all of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.

    • noneSatisfy

      boolean noneSatisfy​(BytePredicate predicate)
      Returns true if none of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.

    • toList

      MutableByteList toList()
      Converts the ByteIterable to a new MutableByteList.

    • toSet

      MutableByteSet toSet()
      Converts the ByteIterable to a new MutableByteSet.

    • toBag

      MutableByteBag toBag()
      Converts the ByteIterable to a new MutableByteBag.

    • asLazy

      LazyByteIterable asLazy()
      Returns a LazyByteIterable adapter wrapping the source ByteIterable.

    • injectInto

      <T> T injectInto​(T injectedValue, ObjectByteToObjectFunction<? super T,​? extends T> function)

    • reduceIfEmpty

      default long reduceIfEmpty​(LongByteToLongFunction accumulator, long defaultValue)
      Since:
      10.0
      See Also:
      reduce(LongByteToLongFunction)

    • reduce

      default long reduce​(LongByteToLongFunction accumulator)
      Since:
      10.0
      See Also:
      RichIterable.reduce(BinaryOperator)

    • chunk

      default RichIterable<ByteIterable> chunk​(int size)
      Partitions elements in fixed size chunks.
      Parameters:
      size - the number of elements per chunk
      Returns:
      A RichIterable containing ByteIterables of size size, except the last will be truncated if the elements don't divide evenly.
      Since:
      9.2

    • sum

      long sum()

    • summaryStatistics

      default IntSummaryStatistics summaryStatistics()
      Since:
      8.0

    • max

      byte max()

    • maxIfEmpty

      byte maxIfEmpty​(byte defaultValue)

    • min

      byte min()

    • minIfEmpty

      byte minIfEmpty​(byte 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

      byte[] toSortedArray()

    • toSortedList

      MutableByteList toSortedList()