Package org.eclipse.collections.impl.utility

Class Iterate

  • public final class Iterate
extends Object
    A utility class that 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 Detail

      • 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());

      • 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);

      • 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()));

      • 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"));

      • 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));

      • 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");

      • 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"));

      • 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");
        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"));

      • 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");

      • 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 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 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));

      • 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 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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());

      • 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"));

      • 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");

      • 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

      • 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

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

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

      • getOnly

        public static <T> T getOnly​(Iterable<T> iterable)
        Returns the only element of a collection.
        Throws:
        IllegalArgumentException - if the Collection is null, empty, or has more than one element.

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