Class AbstractImmutableList<T>

    • Constructor Detail

      • AbstractImmutableList

        AbstractImmutableList()
    • Method Detail

      • equals

        public boolean equals​(java.lang.Object that)
        Description copied from interface: ListIterable
        Follows the same general contract as List.equals(Object).
        Specified by:
        equals in interface java.util.Collection<T>
        Specified by:
        equals in interface java.util.List<T>
        Specified by:
        equals in interface ListIterable<T>
        Overrides:
        equals in class java.lang.Object
      • randomAccessListEquals

        private boolean randomAccessListEquals​(java.util.List<?> list)
      • regularListEquals

        protected boolean regularListEquals​(java.util.List<?> list)
      • hashCode

        public int hashCode()
        Description copied from interface: ListIterable
        Follows the same general contract as List.hashCode().
        Specified by:
        hashCode in interface java.util.Collection<T>
        Specified by:
        hashCode in interface java.util.List<T>
        Specified by:
        hashCode in interface ListIterable<T>
        Overrides:
        hashCode in class java.lang.Object
      • getFirst

        public T getFirst()
        Description copied from interface: RichIterable
        Returns the first element of an iterable. 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 iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

        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.

        Specified by:
        getFirst in interface ListIterable<T>
        Specified by:
        getFirst in interface OrderedIterable<T>
        Specified by:
        getFirst in interface RichIterable<T>
      • getLast

        public T getLast()
        Description copied from interface: RichIterable
        Returns the last element of an iterable. 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 iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

        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.

        Specified by:
        getLast in interface ListIterable<T>
        Specified by:
        getLast in interface OrderedIterable<T>
        Specified by:
        getLast in interface RichIterable<T>
      • select

        public ImmutableList<T> select​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter.

        Example using a Java 8 lambda expression:

         RichIterable<Person> selected =
             people.select(person -> person.getAddress().getCity().equals("London"));
         

        Example using an anonymous inner class:

         RichIterable<Person> selected =
             people.select(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.getAddress().getCity().equals("London");
                 }
             });
         
        Specified by:
        select in interface ImmutableCollection<T>
        Specified by:
        select in interface ImmutableList<T>
        Specified by:
        select in interface ListIterable<T>
        Specified by:
        select in interface OrderedIterable<T>
        Specified by:
        select in interface ReversibleIterable<T>
        Specified by:
        select in interface RichIterable<T>
      • selectWith

        public <P,​R extends java.util.Collection<T>> R selectWith​(Predicate2<? super T,​? super P> predicate,
                                                                        P parameter,
                                                                        R target)
        Description copied from interface: RichIterable
        Similar to RichIterable.select(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

        E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years

        Example using a Java 8 lambda expression:

         MutableList<Person> selected =
             people.selectWith((Person person, Integer age) -> person.getAge()>= age, Integer.valueOf(18), Lists.mutable.empty());
         

        Example using an anonymous inner class:

         MutableList<Person> selected =
             people.selectWith(new Predicate2<Person, Integer>()
             {
                 public boolean accept(Person person, Integer age)
                 {
                     return person.getAge()>= age;
                 }
             }, Integer.valueOf(18), Lists.mutable.empty());
         
        Specified by:
        selectWith in interface RichIterable<T>
        Overrides:
        selectWith in class AbstractRichIterable<T>
        Parameters:
        predicate - a Predicate2 to use as the select criteria
        parameter - a parameter to pass in for evaluation of the second argument P in predicate
        target - the Collection to append to for all elements in this RichIterable that meet select criteria predicate
        Returns:
        targetCollection, which contains appended elements as a result of the select criteria
        See Also:
        RichIterable.select(Predicate), RichIterable.select(Predicate, Collection)
      • reject

        public ImmutableList<T> reject​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Returns all elements of the source collection that return false when evaluating of the predicate. This method is also sometimes called filterNot and is the equivalent of calling iterable.select(Predicates.not(predicate)).

        Example using a Java 8 lambda expression:

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

        Example using an anonymous inner class:

         RichIterable<Person> rejected =
             people.reject(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.person.getLastName().equals("Smith");
                 }
             });
         
        Specified by:
        reject in interface ImmutableCollection<T>
        Specified by:
        reject in interface ImmutableList<T>
        Specified by:
        reject in interface ListIterable<T>
        Specified by:
        reject in interface OrderedIterable<T>
        Specified by:
        reject in interface ReversibleIterable<T>
        Specified by:
        reject in interface RichIterable<T>
        Parameters:
        predicate - a Predicate to use as the reject criteria
        Returns:
        a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false
      • rejectWith

        public <P,​R extends java.util.Collection<T>> R rejectWith​(Predicate2<? super T,​? super P> predicate,
                                                                        P parameter,
                                                                        R target)
        Description copied from interface: RichIterable
        Similar to RichIterable.reject(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

        E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years

        Example using a Java 8 lambda expression:

         MutableList<Person> rejected =
             people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18), Lists.mutable.empty());
         

        Example using an anonymous inner class:

         MutableList<Person> rejected =
             people.rejectWith(new Predicate2<Person, Integer>()
             {
                 public boolean accept(Person person, Integer age)
                 {
                     return person.getAge() < age;
                 }
             }, Integer.valueOf(18), Lists.mutable.empty());
         
        Specified by:
        rejectWith in interface RichIterable<T>
        Overrides:
        rejectWith in class AbstractRichIterable<T>
        Parameters:
        predicate - a Predicate2 to use as the reject criteria
        parameter - a parameter to pass in for evaluation of the second argument P in predicate
        target - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to false
        Returns:
        targetCollection, which contains appended elements as a result of the reject criteria
        See Also:
        RichIterable.reject(Predicate), RichIterable.reject(Predicate, Collection)
      • partition

        public PartitionImmutableList<T> partition​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Filters a collection into a PartitionedIterable based on the evaluation of the predicate.

        Example using a Java 8 lambda expression:

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

        Example using an anonymous inner class:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partition(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.getAddress().getState().getName().equals("New York");
                 }
             });
         
        Specified by:
        partition in interface ImmutableCollection<T>
        Specified by:
        partition in interface ImmutableList<T>
        Specified by:
        partition in interface ListIterable<T>
        Specified by:
        partition in interface OrderedIterable<T>
        Specified by:
        partition in interface ReversibleIterable<T>
        Specified by:
        partition in interface RichIterable<T>
      • partitionWith

        public <P> PartitionImmutableList<T> partitionWith​(Predicate2<? super T,​? super P> predicate,
                                                           P parameter)
        Description copied from interface: RichIterable
        Filters a collection into a PartitionIterable based on the evaluation of the predicate.

        Example using a Java 8 lambda expression:

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

        Example using an anonymous inner class:

         PartitionIterable<Person> newYorkersAndNonNewYorkers =
             people.partitionWith(new Predicate2<Person, String>()
             {
                 public boolean accept(Person person, String state)
                 {
                     return person.getAddress().getState().getName().equals(state);
                 }
             }, "New York");
         
        Specified by:
        partitionWith in interface ImmutableCollection<T>
        Specified by:
        partitionWith in interface ImmutableList<T>
        Specified by:
        partitionWith in interface ListIterable<T>
        Specified by:
        partitionWith in interface OrderedIterable<T>
        Specified by:
        partitionWith in interface ReversibleIterable<T>
        Specified by:
        partitionWith in interface RichIterable<T>
      • collect

        public <V> ImmutableList<V> collect​(Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

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

        Example using an anonymous inner class:

         RichIterable<String> names =
             people.collect(new Function<Person, String>()
             {
                 public String valueOf(Person person)
                 {
                     return person.getFirstName() + " " + person.getLastName();
                 }
             });
         
        Specified by:
        collect in interface ImmutableCollection<T>
        Specified by:
        collect in interface ImmutableList<T>
        Specified by:
        collect in interface ListIterable<T>
        Specified by:
        collect in interface OrderedIterable<T>
        Specified by:
        collect in interface ReversibleIterable<T>
        Specified by:
        collect in interface RichIterable<T>
      • collectShort

        public ImmutableShortList collectShort​(ShortFunction<? super T> shortFunction)
        Description copied from interface: RichIterable
        Returns a new primitive short iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.

        Example using a Java 8 lambda expression:

         ShortIterable shorts =
             people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
         

        Example using an anonymous inner class:

         ShortIterable shorts =
             people.collectShort(new ShortFunction<Person>()
             {
                 public short shortValueOf(Person person)
                 {
                     return person.getNumberOfJunkMailItemsReceivedPerMonth();
                 }
             });
         
        Specified by:
        collectShort in interface ImmutableCollection<T>
        Specified by:
        collectShort in interface ImmutableList<T>
        Specified by:
        collectShort in interface ListIterable<T>
        Specified by:
        collectShort in interface OrderedIterable<T>
        Specified by:
        collectShort in interface ReversibleIterable<T>
        Specified by:
        collectShort in interface RichIterable<T>
      • collectWith

        public <P,​V> ImmutableList<V> collectWith​(Function2<? super T,​? super P,​? extends V> function,
                                                        P parameter)
        Description copied from interface: RichIterable
        Same as RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block.

        Example using a Java 8 lambda expression:

         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
         

        Example using an anonymous inner class:

         Function2<Integer, Integer, Integer> addParameterFunction =
             new Function2<Integer, Integer, Integer>()
             {
                 public Integer value(Integer each, Integer parameter)
                 {
                     return each + parameter;
                 }
             };
         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
         
        Specified by:
        collectWith in interface ImmutableCollection<T>
        Specified by:
        collectWith in interface ImmutableList<T>
        Specified by:
        collectWith in interface ListIterable<T>
        Specified by:
        collectWith in interface OrderedIterable<T>
        Specified by:
        collectWith in interface ReversibleIterable<T>
        Specified by:
        collectWith in interface RichIterable<T>
        Parameters:
        function - A Function2 to use as the collect transformation function
        parameter - A parameter to pass in for evaluation of the second argument P in function
        Returns:
        A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
        See Also:
        RichIterable.collect(Function)
      • collectIf

        public <V> ImmutableList<V> collectIf​(Predicate<? super T> predicate,
                                              Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. This is the optimized equivalent of calling iterable.select(predicate).collect(function).

        Example using a Java 8 lambda and method reference:

         RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString);
         

        Example using Predicates factory:

         RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
         
        Specified by:
        collectIf in interface ImmutableCollection<T>
        Specified by:
        collectIf in interface ImmutableList<T>
        Specified by:
        collectIf in interface ListIterable<T>
        Specified by:
        collectIf in interface OrderedIterable<T>
        Specified by:
        collectIf in interface ReversibleIterable<T>
        Specified by:
        collectIf in interface RichIterable<T>
      • collectWith

        public <P,​V,​R extends java.util.Collection<V>> R collectWith​(Function2<? super T,​? super P,​? extends V> function,
                                                                                 P parameter,
                                                                                 R target)
        Description copied from interface: RichIterable
        Same as collectWith but with a targetCollection parameter to gather the results.

        Example using a Java 8 lambda expression:

         MutableSet<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1), Sets.mutable.empty());
         

        Example using an anonymous inner class:

         Function2<Integer, Integer, Integer> addParameterFunction =
             new Function2<Integer, Integer, Integer>()
             {
                 public Integer value(final Integer each, final Integer parameter)
                 {
                     return each + parameter;
                 }
             };
         MutableSet<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1), Sets.mutable.empty());
         
        Specified by:
        collectWith in interface RichIterable<T>
        Overrides:
        collectWith in class AbstractRichIterable<T>
        Parameters:
        function - a Function2 to use as the collect transformation function
        parameter - a parameter to pass in for evaluation of the second argument P in function
        target - the Collection to append to for all elements in this RichIterable that meet select criteria function
        Returns:
        targetCollection, which contains appended elements as a result of the collect transformation
      • flatCollect

        public <V> ImmutableList<V> flatCollect​(Function<? super T,​? extends java.lang.Iterable<V>> function)
        Description copied from interface: RichIterable
        flatCollect is a special case of RichIterable.collect(Function). With collect, when the Function returns a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection instead. This method is commonly called flatMap.

        Consider the following example where we have a Person class, and each Person has a list of Address objects. Take the following Function:

         Function<Person, List<Address>> addressFunction = Person::getAddresses;
         RichIterable<Person> people = ...;
         
        Using collect returns a collection of collections of addresses.
         RichIterable<List<Address>> addresses = people.collect(addressFunction);
         
        Using flatCollect returns a single flattened list of addresses.
         RichIterable<Address> addresses = people.flatCollect(addressFunction);
         
        Specified by:
        flatCollect in interface ImmutableCollection<T>
        Specified by:
        flatCollect in interface ImmutableList<T>
        Specified by:
        flatCollect in interface ListIterable<T>
        Specified by:
        flatCollect in interface OrderedIterable<T>
        Specified by:
        flatCollect in interface ReversibleIterable<T>
        Specified by:
        flatCollect in interface RichIterable<T>
        Parameters:
        function - The Function to apply
        Returns:
        a new flattened collection produced by applying the given function
      • flatCollect

        public <V,​R extends java.util.Collection<V>> R flatCollect​(Function<? super T,​? extends java.lang.Iterable<V>> function,
                                                                         R target)
        Description copied from interface: RichIterable
        Same as flatCollect, only the results are collected into the target collection.
        Specified by:
        flatCollect in interface RichIterable<T>
        Overrides:
        flatCollect in class AbstractRichIterable<T>
        Parameters:
        function - The Function to apply
        target - The collection into which results should be added.
        Returns:
        target, which will contain a flattened collection of results produced by applying the given function
        See Also:
        RichIterable.flatCollect(Function)
      • detectIndex

        public int detectIndex​(Predicate<? super T> predicate)
        Description copied from interface: OrderedIterable
        Returns the index of the first element of the OrderedIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
        Specified by:
        detectIndex in interface OrderedIterable<T>
      • detectLastIndex

        public int detectLastIndex​(Predicate<? super T> predicate)
        Description copied from interface: ReversibleIterable
        Returns the index of the last element of the ReversibleIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
        Specified by:
        detectLastIndex in interface ReversibleIterable<T>
      • count

        public int count​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Return the total number of elements that answer true to the specified predicate.

        Example using a Java 8 lambda expression:

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

        Example using an anonymous inner class:

         int count =
             people.count(new Predicate<Person>()
             {
                 public boolean accept(Person person)
                 {
                     return person.getAddress().getState().getName().equals("New York");
                 }
             });
         
        Specified by:
        count in interface RichIterable<T>
        Overrides:
        count in class AbstractRichIterable<T>
      • injectInto

        public <IV> IV injectInto​(IV injectedValue,
                                  Function2<? super IV,​? super T,​? extends IV> function)
        Description copied from interface: RichIterable
        Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter. This method is commonly called fold or sometimes reduce.
        Specified by:
        injectInto in interface RichIterable<T>
        Overrides:
        injectInto in class AbstractRichIterable<T>
      • injectInto

        public int injectInto​(int injectedValue,
                              IntObjectToIntFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Specified by:
        injectInto in interface RichIterable<T>
        Overrides:
        injectInto in class AbstractRichIterable<T>
      • injectInto

        public long injectInto​(long injectedValue,
                               LongObjectToLongFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Specified by:
        injectInto in interface RichIterable<T>
        Overrides:
        injectInto in class AbstractRichIterable<T>
      • injectInto

        public double injectInto​(double injectedValue,
                                 DoubleObjectToDoubleFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Specified by:
        injectInto in interface RichIterable<T>
        Overrides:
        injectInto in class AbstractRichIterable<T>
      • injectInto

        public float injectInto​(float injectedValue,
                                FloatObjectToFloatFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.
        Specified by:
        injectInto in interface RichIterable<T>
        Overrides:
        injectInto in class AbstractRichIterable<T>
      • sumOfFloat

        public double sumOfFloat​(FloatFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.
        Specified by:
        sumOfFloat in interface RichIterable<T>
        Overrides:
        sumOfFloat in class AbstractRichIterable<T>
      • sumOfDouble

        public double sumOfDouble​(DoubleFunction<? super T> function)
        Description copied from interface: RichIterable
        Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.
        Specified by:
        sumOfDouble in interface RichIterable<T>
        Overrides:
        sumOfDouble in class AbstractRichIterable<T>
      • corresponds

        public <S> boolean corresponds​(OrderedIterable<S> other,
                                       Predicate2<? super T,​? super S> predicate)
        Description copied from interface: OrderedIterable
        Returns true if both OrderedIterables have the same length and predicate returns true for all corresponding elements e1 of this OrderedIterable and e2 of other. The predicate is evaluated for each element at the same position of each OrderedIterable in a forward iteration order. This is a short circuit pattern.
        Specified by:
        corresponds in interface OrderedIterable<T>
      • forEachWithIndex

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

        Example using a Java 8 lambda:

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

        Example using an anonymous inner class:

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

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

        Example using a Java 8 lambda:

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

        Example using an anonymous inner class:

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

        public void forEach​(int from,
                            int to,
                            Procedure<? super T> procedure)
        Description copied from interface: OrderedIterable
        Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
        e.g.
         OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
         people.forEach(0, 1, new Procedure<Person>()
         {
             public void value(Person person)
             {
                  LOGGER.info(person.getName());
             }
         });
         

        This code would output ted and mary's names.

        Specified by:
        forEach in interface OrderedIterable<T>
      • forEachWithIndex

        public void forEachWithIndex​(int from,
                                     int to,
                                     ObjectIntProcedure<? super T> objectIntProcedure)
        Description copied from interface: OrderedIterable
        Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
        e.g.
         OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
         people.forEachWithIndex(0, 1, new ObjectIntProcedure<Person>()
         {
             public void value(Person person, int index)
             {
                  LOGGER.info(person.getName());
             }
         });
         

        This code would output ted and mary's names.

        Specified by:
        forEachWithIndex in interface OrderedIterable<T>
      • indexOf

        public int indexOf​(java.lang.Object object)
        Description copied from interface: OrderedIterable
        Returns the index of the first occurrence of the specified item in this iterable, or -1 if this iterable does not contain the item.
        Specified by:
        indexOf in interface java.util.List<T>
        Specified by:
        indexOf in interface OrderedIterable<T>
        See Also:
        List.indexOf(Object)
      • lastIndexOf

        public int lastIndexOf​(java.lang.Object object)
        Description copied from interface: ListIterable
        Returns the index of the last occurrence of the specified item in this list, or -1 if this list does not contain the item.
        Specified by:
        lastIndexOf in interface java.util.List<T>
        Specified by:
        lastIndexOf in interface ListIterable<T>
      • iterator

        public java.util.Iterator<T> iterator()
        Specified by:
        iterator in interface java.util.Collection<T>
        Specified by:
        iterator in interface java.lang.Iterable<T>
        Specified by:
        iterator in interface java.util.List<T>
      • addAll

        public boolean addAll​(int index,
                              java.util.Collection<? extends T> collection)
        Specified by:
        addAll in interface java.util.List<T>
      • set

        public T set​(int index,
                     T element)
        Specified by:
        set in interface java.util.List<T>
      • add

        public void add​(int index,
                        T element)
        Specified by:
        add in interface java.util.List<T>
      • remove

        public T remove​(int index)
        Specified by:
        remove in interface java.util.List<T>
      • replaceAll

        public void replaceAll​(java.util.function.UnaryOperator<T> operator)
        Specified by:
        replaceAll in interface java.util.List<T>
        Since:
        10.0 - Override for correctness
      • sort

        public void sort​(java.util.Comparator<? super T> c)
        Specified by:
        sort in interface java.util.List<T>
        Since:
        10.0 - Override for correctness
      • listIterator

        public java.util.ListIterator<T> listIterator()
        Specified by:
        listIterator in interface java.util.List<T>
        Specified by:
        listIterator in interface ListIterable<T>
        See Also:
        List.listIterator()
      • listIterator

        public java.util.ListIterator<T> listIterator​(int index)
        Specified by:
        listIterator in interface java.util.List<T>
        Specified by:
        listIterator in interface ListIterable<T>
        See Also:
        List.listIterator(int)
      • groupBy

        public <V> ImmutableListMultimap<V,​T> groupBy​(Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.

        Example using a Java 8 method reference:

         Multimap<String, Person> peopleByLastName =
             people.groupBy(Person::getLastName);
         

        Example using an anonymous inner class:

         Multimap<String, Person> peopleByLastName =
             people.groupBy(new Function<Person, String>()
             {
                 public String valueOf(Person person)
                 {
                     return person.getLastName();
                 }
             });
         
        Specified by:
        groupBy in interface ImmutableCollection<T>
        Specified by:
        groupBy in interface ImmutableList<T>
        Specified by:
        groupBy in interface ListIterable<T>
        Specified by:
        groupBy in interface OrderedIterable<T>
        Specified by:
        groupBy in interface ReversibleIterable<T>
        Specified by:
        groupBy in interface RichIterable<T>
      • groupBy

        public <V,​R extends MutableMultimap<V,​T>> R groupBy​(Function<? super T,​? extends V> function,
                                                                        R target)
        Description copied from interface: RichIterable
        Same as RichIterable.groupBy(Function), except that the results are gathered into the specified target multimap.

        Example using a Java 8 method reference:

         FastListMultimap<String, Person> peopleByLastName =
             people.groupBy(Person::getLastName, new FastListMultimap<String, Person>());
         

        Example using an anonymous inner class:

         FastListMultimap<String, Person> peopleByLastName =
             people.groupBy(new Function<Person, String>()
             {
                 public String valueOf(Person person)
                 {
                     return person.getLastName();
                 }
             }, new FastListMultimap<String, Person>());
         
        Specified by:
        groupBy in interface RichIterable<T>
        Overrides:
        groupBy in class AbstractRichIterable<T>
      • min

        public T min​(java.util.Comparator<? super T> comparator)
        Description copied from interface: RichIterable
        Returns the minimum element out of this container based on the comparator.
        Specified by:
        min in interface RichIterable<T>
        Overrides:
        min in class AbstractRichIterable<T>
      • max

        public T max​(java.util.Comparator<? super T> comparator)
        Description copied from interface: RichIterable
        Returns the maximum element out of this container based on the comparator.
        Specified by:
        max in interface RichIterable<T>
        Overrides:
        max in class AbstractRichIterable<T>
      • minBy

        public <V extends java.lang.Comparable<? super V>> T minBy​(Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.
        Specified by:
        minBy in interface RichIterable<T>
        Overrides:
        minBy in class AbstractRichIterable<T>
      • maxBy

        public <V extends java.lang.Comparable<? super V>> T maxBy​(Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.
        Specified by:
        maxBy in interface RichIterable<T>
        Overrides:
        maxBy in class AbstractRichIterable<T>
      • zip

        public <S> ImmutableList<Pair<T,​S>> zip​(java.lang.Iterable<S> that)
        Description copied from interface: RichIterable
        Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs. If one of the two RichIterables is longer than the other, its remaining elements are ignored.
        Specified by:
        zip in interface ImmutableCollection<T>
        Specified by:
        zip in interface ImmutableList<T>
        Specified by:
        zip in interface ListIterable<T>
        Specified by:
        zip in interface OrderedIterable<T>
        Specified by:
        zip in interface ReversibleIterable<T>
        Specified by:
        zip in interface RichIterable<T>
        Type Parameters:
        S - the type of the second half of the returned pairs
        Parameters:
        that - The RichIterable providing the second half of each result pair
        Returns:
        A new RichIterable containing pairs consisting of corresponding elements of this RichIterable and that. The length of the returned RichIterable is the minimum of the lengths of this RichIterable and that.
      • take

        public ImmutableList<T> take​(int count)
        Description copied from interface: ReversibleIterable
        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.
        Specified by:
        take in interface ImmutableList<T>
        Specified by:
        take in interface ListIterable<T>
        Specified by:
        take in interface ReversibleIterable<T>
        Parameters:
        count - the number of items to take.
      • drop

        public ImmutableList<T> drop​(int count)
        Description copied from interface: ReversibleIterable
        Returns an iterable after skipping the first count elements or an empty iterable if the count is greater than the length of the iterable.
        Specified by:
        drop in interface ImmutableList<T>
        Specified by:
        drop in interface ListIterable<T>
        Specified by:
        drop in interface ReversibleIterable<T>
        Parameters:
        count - the number of items to drop.
      • asParallel

        public ParallelListIterable<T> asParallel​(java.util.concurrent.ExecutorService executorService,
                                                  int batchSize)
        Description copied from interface: ListIterable
        Returns a parallel iterable of this ListIterable.
        Specified by:
        asParallel in interface ListIterable<T>
      • toImmutable

        public ImmutableList<T> toImmutable()
        Description copied from interface: ListIterable
        Converts the ListIterable to an immutable implementation. Returns this for immutable lists.
        Specified by:
        toImmutable in interface ListIterable<T>
      • chunk

        public RichIterable<RichIterable<T>> chunk​(int size)
        Description copied from interface: RichIterable
        Partitions elements in fixed size chunks.
        Specified by:
        chunk in interface RichIterable<T>
        Overrides:
        chunk in class AbstractImmutableCollection<T>
        Parameters:
        size - the number of elements per chunk
        Returns:
        A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.