Package org.eclipse.collections.impl.lazy.primitive

Class CollectByteToObjectIterable<V>

java.lang.Object
org.eclipse.collections.impl.AbstractRichIterable<T>
org.eclipse.collections.impl.lazy.AbstractLazyIterable<V>
org.eclipse.collections.impl.lazy.primitive.CollectByteToObjectIterable<V>
All Implemented Interfaces:
Iterable<V>, InternalIterable<V>, LazyIterable<V>, RichIterable<V>
public class CollectByteToObjectIterable<V> extends AbstractLazyIterable<V>
This file was automatically generated from template file collectPrimitiveToObjectIterable.stg.

  • Constructor Details

  • Method Details

    • each

      public void each(Procedure<? super V> procedure)
      Description copied from interface: RichIterable
      The procedure is executed for each element in the iterable.

      Example using a Java 8 lambda expression: 

       people.each(person -> LOGGER.info(person.getName()));

      Example using an anonymous inner class: 

       people.each(new Procedure<Person>()
 {
     public void value(Person person)
     {
         LOGGER.info(person.getName());
     }
 });
      This method is a variant of InternalIterable.forEach(Procedure) that has a signature conflict with Iterable.forEach(java.util.function.Consumer).
      See Also:

    • forEachWithIndex

      public void forEachWithIndex(ObjectIntProcedure<? super V> objectIntProcedure)
      Description copied from interface: InternalIterable
      Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.

      Example using a Java 8 lambda: 

       people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));

      Example using an anonymous inner class: 

       people.forEachWithIndex(new ObjectIntProcedure<Person>()
 {
     public void value(Person person, int index)
     {
         LOGGER.info("Index: " + index + " person: " + person.getName());
     }
 });
      Specified by:
      forEachWithIndex in interface InternalIterable<V>
      Overrides:
      forEachWithIndex in class AbstractRichIterable<V>

    • forEachWith

      public <P> void forEachWith(Procedure2<? super V,? super P> procedure, P parameter)
      Description copied from interface: InternalIterable
      The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.

      Example using a Java 8 lambda: 

       people.forEachWith((Person person, Person other) ->
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }, fred);

      Example using an anonymous inner class: 

       people.forEachWith(new Procedure2<Person, Person>()
 {
     public void value(Person person, Person other)
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }
 }, fred);
      Specified by:
      forEachWith in interface InternalIterable<V>
      Overrides:
      forEachWith in class AbstractRichIterable<V>

    • iterator

      public Iterator<V> iterator()

    • size

      public int size()
      Description copied from interface: RichIterable
      Returns the number of items in this iterable.
      Specified by:
      size in interface RichIterable<V>
      Overrides:
      size in class AbstractLazyIterable<V>

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: RichIterable
      Returns true if this iterable has zero items.
      Specified by:
      isEmpty in interface RichIterable<V>
      Overrides:
      isEmpty in class AbstractLazyIterable<V>

    • notEmpty

      public boolean notEmpty()
      Description copied from interface: RichIterable
      The English equivalent of !this.isEmpty()