Class AbstractLazyIterable<T>

    • Constructor Detail

      • AbstractLazyIterable

        public AbstractLazyIterable()
    • Method Detail

      • toArray

        public <E> E[] toArray​(E[] array)
        Description copied from interface: RichIterable
        Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable.
        Specified by:
        toArray in interface RichIterable<T>
        Overrides:
        toArray in class AbstractRichIterable<T>
        See Also:
        Collection.toArray(Object[])
      • size

        public int size()
        Description copied from interface: RichIterable
        Returns the number of items in this iterable.
        Specified by:
        size in interface RichIterable<T>
      • 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 LazyIterable<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 RichIterable<T>
      • getOnly

        public T getOnly()
        Description copied from interface: RichIterable
        Returns the element if the iterable has exactly one element. Otherwise, throw IllegalStateException.
        Specified by:
        getOnly in interface RichIterable<T>
        Returns:
        an element of an iterable.
      • selectWith

        public <P> LazyIterable<T> selectWith​(Predicate2<? super T,​? super P> predicate,
                                              P parameter)
        Description copied from interface: RichIterable
        Similar to RichIterable.select(Predicate), 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:

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

        Example using an anonymous inner class:

         RichIterable<Person> selected =
             people.selectWith(new Predicate2<Person, Integer>()
             {
                 public boolean accept(Person person, Integer age)
                 {
                     return person.getAge()>= age;
                 }
             }, Integer.valueOf(18));
         
        Specified by:
        selectWith in interface LazyIterable<T>
        Specified by:
        selectWith in interface RichIterable<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
        See Also:
        RichIterable.select(Predicate)
      • rejectWith

        public <P> LazyIterable<T> rejectWith​(Predicate2<? super T,​? super P> predicate,
                                              P parameter)
        Description copied from interface: RichIterable
        Similar to RichIterable.reject(Predicate), 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:

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

        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));
         
        Specified by:
        rejectWith in interface LazyIterable<T>
        Specified by:
        rejectWith in interface RichIterable<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
        See Also:
        RichIterable.select(Predicate)
      • partition

        public PartitionMutableList<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 RichIterable<T>
      • partitionWith

        public <P> PartitionMutableList<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 RichIterable<T>
      • selectInstancesOf

        public <S> LazyIterable<S> selectInstancesOf​(java.lang.Class<S> clazz)
        Description copied from interface: RichIterable
        Returns all elements of the source collection that are instances of the Class clazz.
         RichIterable<Integer> integers =
             List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
         
        Specified by:
        selectInstancesOf in interface LazyIterable<T>
        Specified by:
        selectInstancesOf in interface RichIterable<T>
      • collectWith

        public <P,​V> LazyIterable<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 LazyIterable<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)
      • flatCollect

        public <V> LazyIterable<V> flatCollect​(Function<? super T,​? extends java.lang.Iterable<V>> function)
        Description copied from interface: LazyIterable
        Creates a deferred flattening iterable for the current iterable.
        Specified by:
        flatCollect in interface LazyIterable<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
      • concatenate

        public LazyIterable<T> concatenate​(java.lang.Iterable<T> iterable)
        Description copied from interface: LazyIterable
        Creates a deferred iterable that will join this iterable with the specified iterable.
        Specified by:
        concatenate in interface LazyIterable<T>
      • take

        public LazyIterable<T> take​(int count)
        Description copied from interface: LazyIterable
        Creates a deferred take iterable for the current iterable using the specified count as the limit.
        Specified by:
        take in interface LazyIterable<T>
      • drop

        public LazyIterable<T> drop​(int count)
        Description copied from interface: LazyIterable
        Creates a deferred drop iterable for the current iterable using the specified count as the limit.
        Specified by:
        drop in interface LazyIterable<T>
      • distinct

        public LazyIterable<T> distinct()
        Description copied from interface: LazyIterable
        Creates a deferred distinct iterable to get distinct elements from the current iterable.
        Specified by:
        distinct in interface LazyIterable<T>
      • groupBy

        public <V> Multimap<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 RichIterable<T>
      • groupByUniqueKey

        public <V> MapIterable<V,​T> groupByUniqueKey​(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 map, where the transformed value is the key. The generated keys must each be unique, or else an exception is thrown.
        Specified by:
        groupByUniqueKey in interface RichIterable<T>
        See Also:
        RichIterable.groupBy(Function)
      • zip

        public <S> LazyIterable<Pair<T,​S>> zip​(java.lang.Iterable<S> that)
        Description copied from interface: LazyIterable
        Creates a deferred zip iterable.
        Specified by:
        zip in interface LazyIterable<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.
      • chunk

        public LazyIterable<RichIterable<T>> chunk​(int size)
        Description copied from interface: LazyIterable
        Creates a deferred chunk iterable.
        Specified by:
        chunk in interface LazyIterable<T>
        Specified by:
        chunk in interface RichIterable<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.
      • minOptional

        public java.util.Optional<T> minOptional​(java.util.Comparator<? super T> comparator)
        Description copied from interface: RichIterable
        Returns the minimum element out of this container based on the comparator as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        minOptional in interface RichIterable<T>
      • maxOptional

        public java.util.Optional<T> maxOptional​(java.util.Comparator<? super T> comparator)
        Description copied from interface: RichIterable
        Returns the maximum element out of this container based on the comparator as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        maxOptional in interface RichIterable<T>
      • minOptional

        public java.util.Optional<T> minOptional()
        Description copied from interface: RichIterable
        Returns the minimum element out of this container based on the natural order as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        minOptional in interface RichIterable<T>
      • maxOptional

        public java.util.Optional<T> maxOptional()
        Description copied from interface: RichIterable
        Returns the maximum element out of this container based on the natural order as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        maxOptional in interface RichIterable<T>
      • minByOptional

        public <V extends java.lang.Comparable<? super V>> java.util.Optional<T> minByOptional​(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 as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        minByOptional in interface RichIterable<T>
      • maxByOptional

        public <V extends java.lang.Comparable<? super V>> java.util.Optional<T> maxByOptional​(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 as an Optional. If the container is empty Optional.empty() is returned.
        Specified by:
        maxByOptional in interface RichIterable<T>