Package org.eclipse.collections.impl.utility

Class Iterate

java.lang.Object
org.eclipse.collections.impl.utility.Iterate
public final class Iterate
extends Object
The Iterate utility class acts as a router to other utility classes to provide optimized iteration pattern implementations based on the type of iterable. The lowest common denominator used will normally be IterableIterate. Iterate can be used when a JDK interface is the only type available to the developer, as it can determine the best way to iterate based on instanceof checks.
Since:
1.0

  • Method Details

    • forEach

      public static <T> void forEach​(Iterable<T> iterable, Procedure<? super T> procedure)
      The procedure is evaluated for each element of the iterable.

      Example using a Java 8 lambda expression: 

       Iterate.forEach(people, person -> LOGGER.info(person.getName());

      Example using an anonymous inner class: 

       Iterate.forEach(people, new Procedure<Person>()
 {
     public void value(Person person)
     {
         LOGGER.info(person.getName());
     }
 });

    • forEachWith

      public static <T,​ P> void forEachWith​(Iterable<T> iterable, Procedure2<? super T,​? super P> procedure, P parameter)
      The procedure2 is evaluated for each element of the iterable with the specified parameter passed as the second argument.

      Example using a Java 8 lambda expression: 

       Iterate.forEachWith(people, (Person person, Person other) ->
  {
      if (other.equals(person))
      {
          LOGGER.info(person.getName());
      }
  }, fred);
 
      e.g.
 Iterate.forEachWith(people, new Procedure2<Person, Person>()
 {
     public void value(Person person, Person other)
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }
 }, fred);

    • forEachWithIndex

      public static <T> void forEachWithIndex​(Iterable<T> iterable, ObjectIntProcedure<? super T> objectIntProcedure)
      Iterates over a collection passing each element and the current relative int index to the specified instance of ObjectIntProcedure.

      Example using a Java 8 lambda expression: 

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

      Example using anonymous inner class: 

       Iterate.forEachWithIndex(people, new ObjectIntProcedure<Person>()
 {
     public void value(Person person, int index)
     {
         LOGGER.info("Index: " + index + " person: " + person.getName());
     }
 });

    • select

      public static <T> Collection<T> select​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns a new collection with only the elements that evaluated to true for the specified predicate.

      Example using a Java 8 lambda expression: 

       Collection<Person> selected =
     Iterate.select(people, person -> person.getAddress().getCity().equals("Metuchen"));

      Example using an anonymous inner class: 

      e.g.
 Collection<Person> selected =
     Iterate.select(people, new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getCity().equals("Metuchen");
         }
     });

    • selectWith

      public static <T,​ IV> Collection<T> selectWith​(Iterable<T> iterable, Predicate2<? super T,​? super IV> predicate, IV parameter)
      Returns a new collection with only elements that evaluated to true for the specified predicate and parameter.

      Example using a Java 8 lambda expression: 

       Collection<Person> selected =
     Iterate.selectWith(people, (Person person, Integer age) -> person.getAge() >= age, Integer.valueOf(18));

      Example using an anonymous inner class: 

       Collection<Person> selected =
      Iterate.selectWith(people, new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() >= age;
         }
     }, Integer.valueOf(18));

    • selectAndRejectWith

      public static <T,​ IV> Twin<MutableList<T>> selectAndRejectWith​(Iterable<T> iterable, Predicate2<? super T,​? super IV> predicate, IV injectedValue)
      Filters a collection into two separate collections based on a predicate returned via a Twin.

      Example using a Java 8 lambda expression: 

       Twin<MutableList<Person>>selectedRejected =
      Iterate.selectAndRejectWith(people, (Person person, String lastName) -> lastName.equals(person.getLastName()), "Mason");

      Example using an anonymous inner class: 

       Twin<MutableList<Person>>selectedRejected =
      Iterate.selectAndRejectWith(people, new Predicate2<String, String>()
      {
          public boolean accept(Person person, String lastName)
          {
              return lastName.equals(person.getLastName());
          }
      }, "Mason");

    • partition

      public static <T> PartitionIterable<T> partition​(Iterable<T> iterable, Predicate<? super T> predicate)
      Filters a collection into a PartitionIterable based on a predicate.

      Example using a Java 8 lambda expression: 

       PartitionIterable<Person> newYorkersAndNonNewYorkers =
      Iterate.partition(people, person -> person.getAddress().getState().getName().equals("New York"));

      Example using an anonymous inner class: 

       PartitionIterable<Person> newYorkersAndNonNewYorkers =
      Iterate.partition(people, new Predicate<Person>()
      {
          public boolean accept(Person person)
          {
              return person.getAddress().getState().getName().equals("New York");
          }
      });

    • partitionWith

      public static <T,​ P> PartitionIterable<T> partitionWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Filters a collection into a PartitionIterable based on a predicate.

      Example using a Java 8 lambda expression: 

       PartitionIterable<Person> newYorkersAndNonNewYorkers =
     Iterate.partitionWith(people, (Person person, String state) -> person.getAddress().getState().getName().equals(state), "New York");

      Example using an anonymous inner class: 

       PartitionIterable<Person> newYorkersAndNonNewYorkers =
      Iterate.partitionWith(people, new Predicate<Person, String>()
      {
          public boolean accept(Person person, String state)
          {
              return person.getAddress().getState().getName().equals(state);
          }
      }, "New York");
      Since:
      5.0.

    • selectInstancesOf

      public static <T> Collection<T> selectInstancesOf​(Iterable<?> iterable, Class<T> clazz)
      Returns a new collection with only the elements that are instances of the Class clazz.

    • count

      public static <T> int count​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns the total number of elements that evaluate to true for the specified predicate.

      Example using a Java 8 lambda expression: 

       int count = Iterate.count(people, person -> person.getAddress().getState().getName().equals("New York"));

      Example using anonymous inner class 

       int count = Iterate.count(people, new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.getAddress().getState().getName().equals("New York");
     }
 });

    • countWith

      public static <T,​ IV> int countWith​(Iterable<T> iterable, Predicate2<? super T,​? super IV> predicate, IV injectedValue)
      Returns the total number of elements that evaluate to true for the specified predicate2 and parameter. 
      e.g.
 return Iterate.countWith(lastNames, Predicates2.equal(), "Smith");

    • collectIf

      public static <T,​ V> Collection<V> collectIf​(Iterable<T> iterable, Predicate<? super T> predicate, Function<? super T,​? extends V> function)
      See Also:
      RichIterable.collectIf(Predicate, Function)

    • collectIf

      public static <T,​ V,​ R extends Collection<V>> R collectIf​(Iterable<T> iterable, Predicate<? super T> predicate, Function<? super T,​? extends V> function, R target)
      See Also:
      RichIterable.collectIf(Predicate, Function, Collection)

    • select

      public static <T,​ R extends Collection<T>> R select​(Iterable<T> iterable, Predicate<? super T> predicate, R targetCollection)
      Same as the select method with two parameters but uses the specified target collection

      Example using Java 8 lambda: 

       MutableList<Person> selected =
      Iterate.select(people, person -> person.person.getLastName().equals("Smith"), FastList.newList());

      Example using anonymous inner class: 

       MutableList<Person> selected =
      Iterate.select(people, new Predicate<Person>()
      {
          public boolean accept(Person person)
          {
         return person.person.getLastName().equals("Smith");
     }
 }, FastList.newList());

      Example using Predicates factory: 

       MutableList<Person> selected = Iterate.select(collection, Predicates.attributeEqual("lastName", "Smith"), FastList.newList());

    • selectWith

      public static <T,​ P,​ R extends Collection<T>> R selectWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter, R targetCollection)
      Same as the selectWith method with two parameters but uses the specified target collection.

    • take

      public static <T> Collection<T> take​(Iterable<T> iterable, int count)
      Returns the first count elements of the iterable or all the elements in the iterable if count is greater than the length of the iterable.
      Parameters:
      iterable - the collection to take from.
      count - the number of items to take.
      Returns:
      a new list with the items take from the given collection.
      Throws:
      IllegalArgumentException - if count is less than zero

    • drop

      public static <T> Collection<T> drop​(Iterable<T> iterable, int count)
      Returns a collection without the first count elements of the iterable or an empty iterable if the count is greater than the length of the iterable.
      Parameters:
      iterable - the collection to drop from.
      count - the number of items to drop.
      Returns:
      a new list with the items dropped from the given collection.
      Throws:
      IllegalArgumentException - if count is less than zero

    • reject

      public static <T> Collection<T> reject​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns all elements of the iterable that evaluate to false for the specified predicate.

      Example using Java 8 lambda: 

       Collection<Person> rejected =
      Iterate.reject(people, person -> person.person.getLastName().equals("Smith"));

      Example using anonymous inner class: 

       Collection<Person> rejected =
      Iterate.reject(people,
          new Predicate<Person>()
          {
              public boolean accept(Person person)
              {
                  return person.person.getLastName().equals("Smith");
              }
          });

      Example using Predicates factory: 

       Collection<Person> rejected =
      Iterate.reject(people, Predicates.attributeEqual("lastName", "Smith"));

    • sortThis

      public static <T extends Comparable<? super T>,​ L extends List<T>> L sortThis​(L list)
      SortThis is a mutating method. The List passed in is also returned.

    • sortThis

      public static <T,​ L extends List<T>> L sortThis​(L list, Comparator<? super T> comparator)
      SortThis is a mutating method. The List passed in is also returned.

    • sortThis

      public static <T,​ L extends List<T>> L sortThis​(L list, Predicate2<? super T,​? super T> predicate)
      SortThis is a mutating method. The List passed in is also returned.

    • sortThisBy

      public static <T,​ V extends Comparable<? super V>,​ L extends List<T>> L sortThisBy​(L list, Function<? super T,​? extends V> function)
      Sort the list by comparing an attribute defined by the function. SortThisBy is a mutating method. The List passed in is also returned.

    • removeIf

      public static <T> boolean removeIf​(Iterable<T> iterable, Predicate<? super T> predicate)
      Removes all elements from the iterable that evaluate to true for the specified predicate.

    • removeIfWith

      public static <T,​ P> boolean removeIfWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Removes all elements of the iterable that evaluate to true for the specified predicate2 and parameter.

    • rejectWith

      public static <T,​ P> Collection<T> rejectWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Similar to reject(Iterable, Predicate), except with an evaluation parameter for the second generic argument in Predicate2.

      Example using a Java 8 lambda expression: 

       Collection<Person> rejected =
     Iterate.rejectWith(people, (Person person, Integer age) -> person.getAge() >= age, Integer.valueOf(18));

      Example using an anonymous inner class: 

       Collection<Person> rejected =
      Iterate.rejectWith(people, new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() >= age;
         }
     }, Integer.valueOf(18));

    • reject

      public static <T,​ R extends Collection<T>> R reject​(Iterable<T> iterable, Predicate<? super T> predicate, R targetCollection)
      Same as the reject method with one parameter but uses the specified target collection for the results.

      Example using Java 8 lambda: 

       MutableList<Person> rejected =
      Iterate.reject(people, person -> person.person.getLastName().equals("Smith"), FastList.newList());

      Example using anonymous inner class: 

       MutableList<Person> rejected =
      Iterate.reject(
          people,
          new Predicate<Person>()
          {
              public boolean accept(Person person)
              {
                  return person.person.getLastName().equals("Smith");
              }
          },
          FastList.newList());

      Example using Predicates factory: 

       MutableList<Person> rejected =
      Iterate.reject(people, Predicates.attributeEqual("lastName", "Smith"), FastList.newList());

    • rejectWith

      public static <T,​ P,​ R extends Collection<T>> R rejectWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter, R targetCollection)
      Same as the reject method with two parameters but uses the specified target collection.

    • addAllTo

      public static <T,​ R extends Collection<T>> R addAllTo​(Iterable<? extends T> iterable, R targetCollection)
      Add all elements from the source Iterable to the target collection, return the target collection.

    • addAllIterable

      public static <T> boolean addAllIterable​(Iterable<? extends T> iterable, Collection<T> targetCollection)
      Add all elements from the source Iterable to the target collection, returns true if any element was added.

    • removeAllFrom

      public static <T,​ R extends Collection<T>> R removeAllFrom​(Iterable<? extends T> iterable, R targetCollection)
      Remove all elements present in Iterable from the target collection, return the target collection.

    • removeAllIterable

      public static <T> boolean removeAllIterable​(Iterable<? extends T> iterable, Collection<T> targetCollection)
      Remove all elements present in Iterable from the target collection, returns true if any element was removed.

    • collect

      public static <T,​ V> Collection<V> collect​(Iterable<T> iterable, Function<? super T,​? extends V> function)
      Returns a new collection with the results of applying the specified function for each element of the iterable.

      Example using a Java 8 lambda expression: 

       Collection<String> names =
      Iterate.collect(people, person -> person.getFirstName() + " " + person.getLastName());

      Example using an anonymous inner class: 

       Collection<String> names =
      Iterate.collect(
          people,
          new Function<Person, String>()
          {
              public String valueOf(Person person)
              {
                  return person.getFirstName() + " " + person.getLastName();
              }
          });

    • collect

      public static <T,​ A,​ R extends Collection<A>> R collect​(Iterable<T> iterable, Function<? super T,​? extends A> function, R targetCollection)
      Same as the collect(Iterable, Function) method with two parameters, except that the results are gathered into the specified targetCollection

      Example using a Java 8 lambda expression: 

       MutableList<String> names =
      Iterate.collect(people, person -> person.getFirstName() + " " + person.getLastName(), FastList.newList());

      Example using an anonymous inner class: 

       MutableList<String> names =
      Iterate.collect(
          people,
          new Function<Person, String>()
          {
              public String valueOf(Person person)
              {
                  return person.getFirstName() + " " + person.getLastName();
              }
          },
          FastList.newList());

    • collectBoolean

      public static <T> MutableBooleanCollection collectBoolean​(Iterable<T> iterable, BooleanFunction<? super T> booleanFunction)
      Returns a new primitive boolean collection with the results of applying the specified booleanFunction for each element of the iterable.

      Example using Java 8 lambda: 

       MutableBooleanCollection voters =
      Iterable.collectBoolean(people, person -> person.canVote());

      Example using anonymous inner class: 

       MutableBooleanCollection voters =
      Iterate.collectBoolean(
          people,
          new BooleanFunction<Person>()
          {
              public boolean booleanValueOf(Person person)
              {
                  return person.canVote();
              }
          });

    • collectBoolean

      public static <T,​ R extends MutableBooleanCollection> R collectBoolean​(Iterable<T> iterable, BooleanFunction<? super T> booleanFunction, R target)
      Same as collectBoolean(Iterable, BooleanFunction), except that the results are gathered into the specified target collection.

      Example using Java 8 lambda: 

       BooleanArrayList voters =
      Iterable.collectBoolean(people, person -> person.canVote(), new BooleanArrayList());

      Example using an anonymous inner class: 

       BooleanArrayList voters =
      Iterate.collectBoolean(
          people,
          new BooleanFunction<Person>()
          {
              public boolean booleanValueOf(Person person)
              {
                  return person.canVote();
              }
          },
          new BooleanArrayList());

    • collectByte

      public static <T> MutableByteCollection collectByte​(Iterable<T> iterable, ByteFunction<? super T> byteFunction)
      Returns a new byte collection with the results of applying the specified byteFunction for each element of the iterable.

      Example using Java 8 lambda: 

       MutableByteCollection bytes =
      Iterate.collectByte(people, person -> person.getCode());

      Example using anonymous inner class: 

       MutableByteCollection bytes =
      Iterate.collectByte(
          people,
          new ByteFunction<Person>()
          {
              public byte byteValueOf(Person person)
              {
                  return person.getCode();
              }
          });

    • collectByte

      public static <T,​ R extends MutableByteCollection> R collectByte​(Iterable<T> iterable, ByteFunction<? super T> byteFunction, R target)
      Same as collectByte(Iterable, ByteFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       ByteArrayList bytes =
      Iterate.collectByte(people, person -> person.getCode(), new ByteArrayList());

      Example using an anonymous inner class: 

       ByteArrayList bytes =
      Iterate.collectByte(
          people,
          new ByteFunction<Person>()
          {
              public byte byteValueOf(Person person)
              {
                  return person.getCode();
              }
          },
          new ByteArrayList());

    • collectChar

      public static <T> MutableCharCollection collectChar​(Iterable<T> iterable, CharFunction<? super T> charFunction)
      Returns a new char collection with the results of applying the specified charFunction for each element of the iterable.

      Example using Java 8 lambda: 

       MutableCharCollection chars =
      Iterate.collectChar(people, person -> person.getMiddleInitial());

      Example using anonymous inner class: 

       MutableCharCollection chars =
      Iterate.collectChar(
          people,
          new CharFunction<Person>()
          {
              public char charValueOf(Person person)
              {
                  return person.getMiddleInitial();
              }
          });

    • collectChar

      public static <T,​ R extends MutableCharCollection> R collectChar​(Iterable<T> iterable, CharFunction<? super T> charFunction, R target)
      Same as collectChar(Iterable, CharFunction), except that the results are gathered into the specified target collection. 
       CharArrayList chars =
      Iterate.collectChar(people, person -> person.getMiddleInitial());

      Example using anonymous inner class: 

       CharArrayList chars =
      Iterate.collectChar(
          people,
          new CharFunction<Person>()
          {
              public char charValueOf(Person person)
              {
                  return person.getMiddleInitial();
              }
          },
          new CharArrayList());

    • collectDouble

      public static <T> MutableDoubleCollection collectDouble​(Iterable<T> iterable, DoubleFunction<? super T> doubleFunction)
      Returns a new double collection with the results of applying the specified doubleFunction for each element of the iterable.

      Example using a Java 8 lambda expression: 

       MutableDoubleCollection doubles =
      Iterate.collectDouble(people, person -> person.getMilesFromNorthPole());
      Example using an anonymous inner class: 
       MutableDoubleCollection doubles =
      Iterate.collectDouble(people,
          new DoubleFunction<Person>()
          {
              public double doubleValueOf(Person person)
              {
                  return person.getMilesFromNorthPole();
              }
          });

    • collectDouble

      public static <T,​ R extends MutableDoubleCollection> R collectDouble​(Iterable<T> iterable, DoubleFunction<? super T> doubleFunction, R target)
      Same as collectDouble(Iterable, DoubleFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       DoubleArrayList doubles =
      Iterate.collectDouble(people, person -> person.getMilesFromNorthPole());

      Example using an anonymous inner class: 

       DoubleArrayList doubles =
      Iterate.collectDouble(people,
          new DoubleFunction<Person>()
          {
              public double doubleValueOf(Person person)
              {
                  return person.getMilesFromNorthPole();
              }
          }, new DoubleArrayList());

    • collectFloat

      public static <T> MutableFloatCollection collectFloat​(Iterable<T> iterable, FloatFunction<? super T> floatFunction)
      Returns a new float collection with the results of applying the specified floatFunction for each element of the iterable.

      Example using a Java 8 lambda expression: 

       MutableFloatCollection floats =
      Iterate.collectFloat(people, person -> person.getHeightInInches());

      Example using an anonymous inner class: 

       MutableFloatCollection floats =
      Iterate.collectFloat(people,
          new FloatFunction<Person>()
          {
              public float floatValueOf(Person person)
              {
                  return person.getHeightInInches();
              }
          });

    • collectFloat

      public static <T,​ R extends MutableFloatCollection> R collectFloat​(Iterable<T> iterable, FloatFunction<? super T> floatFunction, R target)
      Same as collectFloat(Iterable, FloatFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       FloatArrayList floats =
      Iterate.collectFloat(people, person -> person.getHeightInInches(), new FloatArrayList());

      Example using an anonymous inner class: 

       FloatArrayList floats =
      Iterate.collectFloat(people,
          new FloatFunction<Person>()
          {
              public float floatValueOf(Person person)
              {
                  return person.getHeightInInches();
              }
          }, new FloatArrayList());

    • collectInt

      public static <T> MutableIntCollection collectInt​(Iterable<T> iterable, IntFunction<? super T> intFunction)
      Returns a new int collection with the results of applying the specified intFunction for each element of the iterable.

      Example using a Java 8 lambda expression: 

       MutableIntCollection ages =
      Iterate.collectInt(people, person -> person.getAge());

      Example using an anonymous inner class: 

       MutableIntCollection ages =
      Iterate.collectInt(people,
          new IntFunction<Person>()
          {
              public int intValueOf(Person person)
              {
                  return person.getAge();
              }
          });

    • collectInt

      public static <T,​ R extends MutableIntCollection> R collectInt​(Iterable<T> iterable, IntFunction<? super T> intFunction, R target)
      Same as collectInt(Iterable, IntFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       IntArrayList ages =
      Iterate.collectInt(people, person -> person.getAge(), new IntArrayList());

      Example using an anonymous inner class: 

       IntArrayList ages =
      Iterate.collectInt(people,
          new IntFunction<Person>()
          {
              public int intValueOf(Person person)
              {
                  return person.getAge();
              }
          }, new IntArrayList());

    • collectLong

      public static <T> MutableLongCollection collectLong​(Iterable<T> iterable, LongFunction<? super T> longFunction)
      Returns a new long collection with the results of applying the specified longFunction for each element of the iterable.

      Example using a Java 8 lambda expression: 

       MutableLongCollection longs =
      Iterate.collectLong(people, person -> person.getGuid());

      Example using an anonymous inner class: 

       MutableLongCollection longs =
      Iterate.collectLong(people,
          new LongFunction<Person>()
          {
              public long longValueOf(Person person)
              {
                  return person.getGuid();
              }
          });

    • collectLong

      public static <T,​ R extends MutableLongCollection> R collectLong​(Iterable<T> iterable, LongFunction<? super T> longFunction, R target)
      Same as collectLong(Iterable, LongFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       LongArrayList longs =
      Iterate.collectLong(people, person -> person.getGuid(), new LongArrayList());

      Example using an anonymous inner class: 

       LongArrayList longs =
      Iterate.collectLong(people,
              new LongFunction<Person>()
              {
                  public long longValueOf(Person person)
                  {
                      return person.getGuid();
                  }
              }, new LongArrayList());

    • collectShort

      public static <T> MutableShortCollection collectShort​(Iterable<T> iterable, ShortFunction<? super T> shortFunction)
      Returns a new short collection with the results of applying the specified shortFunction for each element of the iterable.

      Example using a Java 8 lambda expression: 

       MutableShortCollection shorts =
      Iterate.collectShort(people, person -> person.getNumberOfJunkMailItemsReceivedPerMonth());

      Example using an anonymous inner class: 

       MutableShortCollection shorts =
      Iterate.collectShort(people,
          new ShortFunction<Person>()
          {
              public short shortValueOf(Person person)
              {
                  return person.getNumberOfJunkMailItemsReceivedPerMonth();
              }
          });

    • collectShort

      public static <T,​ R extends MutableShortCollection> R collectShort​(Iterable<T> iterable, ShortFunction<? super T> shortFunction, R target)
      Same as collectShort(Iterable, ShortFunction), except that the results are gathered into the specified target collection.

      Example using a Java 8 lambda expression: 

       ShortArrayList shorts =
      Iterate.collectShort(people, person -> person.getNumberOfJunkMailItemsReceivedPerMonth(), new ShortArrayList());

      Example using an anonymous inner class: 

       ShortArrayList shorts =
      Iterate.collectShort(people,
          new ShortFunction<Person>()
          {
              public short shortValueOf(Person person)
              {
                  return person.getNumberOfJunkMailItemsReceivedPerMonth();
              }
          }, new ShortArrayList());

    • flatCollect

      public static <T,​ V> Collection<V> flatCollect​(Iterable<T> iterable, Function<? super T,​? extends Iterable<V>> function)
      See Also:
      RichIterable.flatCollect(Function)

    • flatCollect

      public static <T,​ A,​ R extends Collection<A>> R flatCollect​(Iterable<T> iterable, Function<? super T,​? extends Iterable<A>> function, R targetCollection)
      See Also:
      RichIterable.flatCollect(Function, Collection)

    • collectWith

      public static <T,​ P,​ A> Collection<A> collectWith​(Iterable<T> iterable, Function2<? super T,​? super P,​? extends A> function, P parameter)
      Same as collect with a Function2 and specified parameter which is passed to the function.

    • collectWith

      public static <T,​ P,​ A,​ R extends Collection<A>> R collectWith​(Iterable<T> iterable, Function2<? super T,​? super P,​? extends A> function, P parameter, R targetCollection)
      Same as collectWith but with a targetCollection parameter to gather the results.

    • flatten

      public static <T> Collection<T> flatten​(Iterable<? extends Iterable<T>> iterable)
      Flattens a collection of collections into one "flat" collection.
      Parameters:
      iterable - A list of lists, e.g. { { 1, 2, 3 }, { 4, 5 }, { 6 } }
      Returns:
      A flattened list, e.g. { 1, 2, 3, 4, 5, 6 }

    • flatten

      public static <T,​ R extends Collection<T>> R flatten​(Iterable<? extends Iterable<T>> iterable, R targetCollection)
      Same as flatten(Iterable) except that the results are gathered into the specified targetCollection.

    • getFirst

      public static <T> T getFirst​(Iterable<T> iterable)
      Returns the first element of a collection. In the case of a List it is the element at the first index. In the case of any other Collection, it is the first element that would be returned during an iteration. If the Collection is empty, the result is null.

      WARNING!!! The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the first element could be any element from the Set.

      Throws:
      IllegalArgumentException - if the Collection is null

    • isEmpty

      public static boolean isEmpty​(Iterable<?> iterable)
      A null-safe check on a collection to see if it isEmpty. A null collection results in a true.

    • notEmpty

      public static boolean notEmpty​(Iterable<?> iterable)
      A null-safe check on a collection to see if it is notEmpty. A null collection results in a false.

    • getLast

      public static <T> T getLast​(Iterable<T> iterable)
      Returns the last element of a collection. In the case of a List it is the element at the last index. In the case of any other Collection, it is the last element that would be returned during an iteration. If the Collection is empty, the result is null.

      WARNING!!! The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the last element could be any element from the Set.

      Throws:
      IllegalArgumentException - if the Collection is null

    • detect

      public static <T> T detect​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns the first element of the iterable that evaluates to true for the specified predicate, or null if no element evaluates to true.

      Example using a Java 8 lambda expression: 

       Person person = Iterate.detect(people, person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));

      Example using an anonymous inner class: 

       Person person = Iterate.detect(people, new Predicate<Person>()
 {
     public boolean accept(Person person)
     {
         return person.getFirstName().equals("John") && person.getLastName().equals("Smith");
     }
 });

    • detectWith

      public static <T,​ P> T detectWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or null if no element evaluates to true.

      Example using a Java 8 lambda expression: 

       Person person = Iterate.detectWith(people, (person, fullName) -> person.getFullName().equals(fullName), "John Smith");

      Example using an anonymous inner class: 

       Person person = Iterate.detectWith(people, new Predicate2<Person, String>()
 {
     public boolean accept(Person person, String fullName)
     {
         return person.getFullName().equals(fullName);
     }
 }, "John Smith");

    • detectOptional

      public static <T> Optional<T> detectOptional​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns the first element of the iterable that evaluates to true for the specified predicate as an Optional.

      Example using a Java 8 lambda expression: 

       Optional<Person> person =
      Iterate.detectOptional(people,
          person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));

      Throws:
      NullPointerException - if the element selected is null
      Since:
      8.0

    • detectWithOptional

      public static <T,​ P> Optional<T> detectWithOptional​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter as an Optional.

      Example using a Java 8 lambda expression: 

       Optional<Person> person =
      Iterate.detectWithOptional(people,
          (person, fullName) -> person.getFullName().equals(fullName), "John Smith");

      Throws:
      NullPointerException - if the element selected is null
      Since:
      8.0

    • detectIfNone

      public static <T> T detectIfNone​(Iterable<T> iterable, Predicate<? super T> predicate, T ifNone)
      Returns the first element of the iterable that evaluates to true for the specified predicate, or returns the result ifNone if no element evaluates to true.

    • detectWithIfNone

      public static <T,​ P> T detectWithIfNone​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter, T ifNone)
      Returns the first element of the iterable that evaluates to true for the specified predicate2 and parameter, or returns the result ifNone if no element evaluates to true.

    • detectIndex

      public static <T> int detectIndex​(Iterable<T> iterable, Predicate<? super T> predicate)
      Searches for the first occurrence where the predicate evaluates to true, returns -1 if the predicate does not evaluate to true.

    • detectIndexWith

      public static <T,​ P> int detectIndexWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Searches for the first occurrence where the predicate2 and parameter evaluates to true, returns -1 if the predicate2 and parameter do not evaluate to true.

    • reduceInPlace

      public static <T,​ A,​ R> R reduceInPlace​(Iterable<T> iterable, Collector<? super T,​A,​R> collector)
      This method produces the equivalent result as Stream.collect(Collector).
      Since:
      8.0

    • reduceInPlace

      public static <T,​ R> R reduceInPlace​(Iterable<T> iterable, Supplier<R> supplier, BiConsumer<R,​? super T> accumulator)
      This method produces the equivalent result as Stream.collect(Supplier, BiConsumer, BiConsumer). The combiner used in collect is unnecessary in the serial case, so is not included in the API.
      Since:
      8.0

    • injectInto

      public static <T,​ IV> IV injectInto​(IV injectValue, Iterable<T> iterable, Function2<? super IV,​? super T,​? extends IV> function)
      See Also:
      RichIterable.injectInto(Object, Function2)

    • injectInto

      public static <T> int injectInto​(int injectValue, Iterable<T> iterable, IntObjectToIntFunction<? super T> function)
      See Also:
      RichIterable.injectInto(int, IntObjectToIntFunction)

    • injectInto

      public static <T> long injectInto​(long injectValue, Iterable<T> iterable, LongObjectToLongFunction<? super T> function)
      See Also:
      RichIterable.injectInto(long, LongObjectToLongFunction)

    • injectInto

      public static <T> double injectInto​(double injectValue, Iterable<T> iterable, DoubleObjectToDoubleFunction<? super T> function)
      See Also:
      RichIterable.injectInto(double, DoubleObjectToDoubleFunction)

    • injectInto

      public static <T> float injectInto​(float injectValue, Iterable<T> iterable, FloatObjectToFloatFunction<? super T> function)
      See Also:
      RichIterable.injectInto(float, FloatObjectToFloatFunction)

    • sumOfInt

      public static <T> long sumOfInt​(Iterable<T> iterable, IntFunction<? super T> function)
      See Also:
      RichIterable.sumOfInt(IntFunction)

    • sumOfLong

      public static <T> long sumOfLong​(Iterable<T> iterable, LongFunction<? super T> function)
      See Also:
      RichIterable.sumOfLong(LongFunction)

    • sumOfFloat

      public static <T> double sumOfFloat​(Iterable<T> iterable, FloatFunction<? super T> function)
      See Also:
      RichIterable.sumOfFloat(FloatFunction)

    • sumOfDouble

      public static <T> double sumOfDouble​(Iterable<T> iterable, DoubleFunction<? super T> function)
      See Also:
      RichIterable.sumOfDouble(DoubleFunction)

    • sumOfBigDecimal

      public static <T> BigDecimal sumOfBigDecimal​(Iterable<T> iterable, Function<? super T,​BigDecimal> function)
      Returns the BigDecimal sum of the result of applying the function to each element of the iterable.
      Since:
      6.0

    • sumOfBigInteger

      public static <T> BigInteger sumOfBigInteger​(Iterable<T> iterable, Function<? super T,​BigInteger> function)
      Returns the BigInteger sum of the result of applying the function to each element of the iterable.
      Since:
      6.0

    • sumByBigDecimal

      public static <V,​ T> MutableMap<V,​BigDecimal> sumByBigDecimal​(Iterable<T> iterable, Function<T,​V> groupBy, Function<? super T,​BigDecimal> function)
      Groups and sums the values of the iterable using the two specified functions.
      Since:
      6.0

    • sumByBigInteger

      public static <V,​ T> MutableMap<V,​BigInteger> sumByBigInteger​(Iterable<T> iterable, Function<T,​V> groupBy, Function<? super T,​BigInteger> function)
      Groups and sums the values of the iterable using the two specified functions.
      Since:
      6.0

    • sumByInt

      public static <T,​ V> ObjectLongMap<V> sumByInt​(Iterable<T> iterable, Function<T,​V> groupBy, IntFunction<? super T> function)
      See Also:
      RichIterable.sumByInt(Function, IntFunction)

    • sumByLong

      public static <T,​ V> ObjectLongMap<V> sumByLong​(Iterable<T> iterable, Function<T,​V> groupBy, LongFunction<? super T> function)
      See Also:
      RichIterable.sumByLong(Function, LongFunction)

    • sumByFloat

      public static <T,​ V> ObjectDoubleMap<V> sumByFloat​(Iterable<T> iterable, Function<T,​V> groupBy, FloatFunction<? super T> function)
      See Also:
      RichIterable.sumOfFloat(FloatFunction)

    • sumByDouble

      public static <T,​ V> ObjectDoubleMap<V> sumByDouble​(Iterable<T> iterable, Function<T,​V> groupBy, DoubleFunction<? super T> function)
      See Also:
      RichIterable.sumOfDouble(DoubleFunction)

    • injectIntoWith

      public static <T,​ IV,​ P> IV injectIntoWith​(IV injectValue, Iterable<T> iterable, Function3<? super IV,​? super T,​? super P,​? extends IV> function, P parameter)
      Similar to injectInto(Object, Iterable, Function2), except with a parameter is used as third generic argument in function3.

    • anySatisfy

      public static <T> boolean anySatisfy​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns true if the predicate evaluates to true for any element of the iterable. Returns false if the iterable is empty or if no elements return true for the predicate.

    • anySatisfyWith

      public static <T,​ P> boolean anySatisfyWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Returns true if the predicate2 and parameter evaluates to true for any element of the iterable. Returns false if the iterable is empty or if no elements return true for the predicate2.

    • allSatisfy

      public static <T> boolean allSatisfy​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns true if the predicate evaluates to true for every element of the iterable, or returns false. Returns true if the iterable is empty.

    • allSatisfyWith

      public static <T,​ P> boolean allSatisfyWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Returns true if the predicate evaluates to true for every element of the iterable, or returns false.

    • noneSatisfy

      public static <T> boolean noneSatisfy​(Iterable<T> iterable, Predicate<? super T> predicate)
      Returns true if the predicate evaluates to false for every element of the iterable, or returns false. Returns true if the iterable is empty.

    • noneSatisfyWith

      public static <T,​ P> boolean noneSatisfyWith​(Iterable<T> iterable, Predicate2<? super T,​? super P> predicate, P parameter)
      Returns true if the predicate evaluates to false for every element of the iterable, or returns false. Returns true if the iterable is empty.

    • toMap

      public static <T,​ K> MutableMap<K,​T> toMap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction)
      Iterate over the specified collection applying the specified Function to each element to calculate a key and return the results as a Map.

    • toMap

      public static <T,​ K,​ V> MutableMap<K,​V> toMap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction, Function<? super T,​? extends V> valueFunction)
      Iterate over the specified collection applying the specified Functions to each element to calculate a key and value, and return the results as a Map.

    • toMap

      public static <T,​ K,​ V,​ R extends Map<K,​ V>> R toMap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction, Function<? super T,​? extends V> valueFunction, R target)
      Iterate over the specified collection applying the specified Functions to each element to calculate a key and value, and return the results in the specified Map instance.

    • addToMap

      public static <T,​ K,​ V,​ M extends Map<K,​ V>> M addToMap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction, M map)
      Iterate over the specified collection applying a specific Function to each element to calculate a key, and add the results to input Map. This method will mutate the input Map.

    • addToMap

      public static <T,​ K,​ V,​ M extends Map<K,​ V>> M addToMap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction, Function<? super T,​? extends V> valueFunction, M map)
      Iterate over the specified collection applying the specified Functions to each element to calculate a key and value, and add the results to input Map. This method will mutate the input Map.

    • toMultimap

      public static <T,​ K,​ V,​ R extends MutableMultimap<K,​ V>> R toMultimap​(Iterable<T> iterable, Function<? super T,​? extends K> keyFunction, Function<? super T,​? extends Iterable<V>> valuesFunction, R targetMultimap)
      Iterate over the specified collection applying the specified Functions to each element to calculate a key and values, add the results to targetMultimap and return the targetMultimap.

      Example using a Java 8 lambda expression: 

       MutableMultimap<String, String> multimap =
      Iterate.toMultimap(integers, each -> "key:" + each, each -> Lists.mutable.of("value:" + each), FastListMultimap.newMultimap());

      Example using an anonymous inner class: 

       MutableMultimap<String, String> multimap =
      Iterate.groupByAndCollect(integers,
          new Function<Integer, String>()
          {
              public String valueOf(Integer each)
              {
                  return "key:" + each;
              }
          }, new Function<Integer, Iterable<String>>()
          {
              public Iterable<String> valueOf(Integer each)
              {
                  return Lists.mutable.of("value:" + each);
              }
          }, FastListMultimap.newMultimap());
      See Also:
      when only keys get transformed, when only keys get transformed and Function returns multiple keys, when both keys and values get transformed and Function returns single key and value

    • toSortedList

      public static <T extends Comparable<? super T>> MutableList<T> toSortedList​(Iterable<T> iterable)
      Return the specified collection as a sorted List.

    • toSortedList

      public static <T> MutableList<T> toSortedList​(Iterable<T> iterable, Comparator<? super T> comparator)
      Return the specified collection as a sorted List using the specified Comparator.

    • sizeOf

      public static int sizeOf​(Iterable<?> iterable)
      Returns the size of an iterable. In the case of Collections and RichIterables, the method size is called. All other iterables will force a complete iteration to happen, which can be unnecessarily costly.

    • contains

      public static boolean contains​(Iterable<?> iterable, Object value)
      Returns true if the iterable contains the value. In the case of Collections and RichIterables, the method contains is called. All other iterables will force a complete iteration to happen, which can be unnecessarily costly.

    • toArray

      public static <T> Object[] toArray​(Iterable<T> iterable)
      Converts the specified iterable to an array.

    • toArray

      public static <T> T[] toArray​(Iterable<? extends T> iterable, T[] target)
      Copies the specified iterable into the specified array.

    • groupBy

      public static <T,​ V> MutableMultimap<V,​T> groupBy​(Iterable<T> iterable, Function<? super T,​? extends V> function)
      See Also:
      RichIterable.groupBy(Function), when function returns multiple keys, when both keys and values get transformed, when both keys and values get transformed and Function returns multiple values

    • groupBy

      public static <T,​ V,​ R extends MutableMultimap<V,​ T>> R groupBy​(Iterable<T> iterable, Function<? super T,​? extends V> function, R targetMultimap)
      See Also:
      RichIterable.groupBy(Function, MutableMultimap), when function returns multiple keys, when both keys and values get transformed, when both keys and values get transformed and Function returns multiple values

    • aggregateInPlaceBy

      public static <T,​ K,​ V> MutableMap<K,​V> aggregateInPlaceBy​(Iterable<T> iterable, Function<? super T,​? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,​? super T> mutatingAggregator)
      See Also:
      RichIterable.aggregateInPlaceBy(Function, Function0, Procedure2)

    • aggregateBy

      public static <T,​ K,​ V> MutableMap<K,​V> aggregateBy​(Iterable<T> iterable, Function<? super T,​? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,​? super T,​? extends V> nonMutatingAggregator)
      See Also:
      RichIterable.aggregateBy(Function, Function0, Function2)

    • groupByEach

      public static <T,​ V> MutableMultimap<V,​T> groupByEach​(Iterable<T> iterable, Function<? super T,​? extends Iterable<V>> function)
      See Also:
      RichIterable.groupByEach(Function), when function returns single key, when both keys and values get transformed, when both keys and values get transformed and Function returns multiple values

    • groupByEach

      public static <T,​ V,​ R extends MutableMultimap<V,​ T>> R groupByEach​(Iterable<T> iterable, Function<? super T,​? extends Iterable<V>> function, R targetCollection)
      See Also:
      RichIterable.groupByEach(Function, MutableMultimap), when function returns single key, when both keys and values get transformed, when both keys and values get transformed and Function returns multiple values

    • groupByAndCollect

      public static <T,​ K,​ V,​ R extends MutableMultimap<K,​ V>> R groupByAndCollect​(Iterable<T> iterable, Function<? super T,​? extends K> groupByFunction, Function<? super T,​? extends V> valueFunction, R targetMultimap)
      Iterate over the specified collection applying the specified Functions to each element to calculate a key and value, add the results to targetMultimap and return the targetMultimap.

      Example using a Java 8 lambda expression: 

       MutableMultimap<String, String> multimap =
      Iterate.groupByAndCollect(integers, each -> "key:" + each, each -> "value:" + each, FastListMultimap.newMultimap());

      Example using an anonymous inner class: 

       MutableMultimap<String, String> multimap =
      Iterate.groupByAndCollect(integers,
          new Function<Integer, String>()
          {
              public String valueOf(Integer each)
              {
                  return "key:" + each;
              }
          }, new Function<Integer, String>()
          {
              public String valueOf(Integer each)
              {
                  return "value:" + each;
              }
          }, FastListMultimap.newMultimap());
      See Also:
      when only keys get transformed, when function returns multiple keys, when both keys and values get transformed and Function returns multiple values

    • groupByUniqueKey

      public static <V,​ T> MutableMap<V,​T> groupByUniqueKey​(Iterable<T> iterable, Function<? super T,​? extends V> function)
      See Also:
      RichIterable.groupByUniqueKey(Function)

    • groupByUniqueKey

      public static <V,​ T,​ R extends MutableMapIterable<V,​ T>> R groupByUniqueKey​(Iterable<T> iterable, Function<? super T,​? extends V> function, R target)
      See Also:
      RichIterable.groupByUniqueKey(Function, MutableMapIterable)

    • min

      public static <T> T min​(Iterable<T> iterable, Comparator<? super T> comparator)
      See Also:
      RichIterable.min(Comparator)

    • max

      public static <T> T max​(Iterable<T> iterable, Comparator<? super T> comparator)
      See Also:
      RichIterable.max(Comparator)

    • min

      public static <T> T min​(Iterable<T> iterable)
      See Also:
      RichIterable.min()

    • max

      public static <T> T max​(Iterable<T> iterable)
      See Also:
      RichIterable.max()

    • getOnly

      public static <T> T getOnly​(Iterable<T> iterable)

    • zip

      public static <X,​ Y> Collection<Pair<X,​Y>> zip​(Iterable<X> xs, Iterable<Y> ys)
      See Also:
      RichIterable.zip(Iterable)

    • zip

      public static <X,​ Y,​ R extends Collection<Pair<X,​ Y>>> R zip​(Iterable<X> xs, Iterable<Y> ys, R targetCollection)
      See Also:
      RichIterable.zip(Iterable, Collection)

    • zipWithIndex

      public static <T> Collection<Pair<T,​Integer>> zipWithIndex​(Iterable<T> iterable)
      See Also:
      RichIterable.zipWithIndex()

    • zipWithIndex

      public static <T,​ R extends Collection<Pair<T,​ Integer>>> R zipWithIndex​(Iterable<T> iterable, R targetCollection)
      See Also:
      RichIterable.zipWithIndex(Collection)

    • chunk

      public static <T> RichIterable<RichIterable<T>> chunk​(Iterable<T> iterable, int size)
      See Also:
      RichIterable.chunk(int)

    • makeString

      public static <T> String makeString​(Iterable<T> iterable)
      See Also:
      RichIterable.makeString()

    • makeString

      public static <T> String makeString​(Iterable<T> iterable, String separator)
      See Also:
      RichIterable.makeString(String)

    • makeString

      public static <T> String makeString​(Iterable<T> iterable, String start, String separator, String end)
      See Also:
      RichIterable.makeString(String, String, String)

    • appendString

      public static <T> void appendString​(Iterable<T> iterable, Appendable appendable)
      See Also:
      RichIterable.appendString(Appendable)

    • appendString

      public static <T> void appendString​(Iterable<T> iterable, Appendable appendable, String separator)
      See Also:
      RichIterable.appendString(Appendable, String)

    • appendString

      public static <T> void appendString​(Iterable<T> iterable, Appendable appendable, String start, String separator, String end)
      See Also:
      RichIterable.appendString(Appendable, String, String, String)

    • maxBy

      public static <T,​ V extends Comparable<? super V>> T maxBy​(Iterable<T> iterable, Function<? super T,​? extends V> function)
      Returns the maximum element out of the iterable based on the natural order of the attribute returned by the function.

    • minBy

      public static <T,​ V extends Comparable<? super V>> T minBy​(Iterable<T> iterable, Function<? super T,​? extends V> function)
      Returns the minimum element out of the iterable based on the natural order of the attribute returned by the function.

    • flip

      public static <K,​ V> HashBagMultimap<V,​K> flip​(BagMultimap<K,​V> bagMultimap)
      Flip the keys and values of the multimap.

    • flip

      public static <K,​ V> HashBagMultimap<V,​K> flip​(ListMultimap<K,​V> listMultimap)
      Flip the keys and values of the multimap.

    • flip

      public static <K,​ V> UnifiedSetMultimap<V,​K> flip​(SetMultimap<K,​V> setMultimap)
      Flip the keys and values of the multimap.