/** * Creates a new FluentIterable from the provided elements. * <p> * The returned iterable's iterator does not support {@code remove()}. * * @param <T> the element type * @param elements the elements to be contained in the FluentIterable * @return a new FluentIterable containing the provided elements */ public static <T> FluentIterable<T> of(final T... elements) { return of(Arrays.asList(elements)); }
/** * Returns a new FluentIterable whose iterator will return at most * the provided maximum number of elements from this iterable. * * @param maxSize the maximum number of elements * @return a new iterable, providing a bounded view of this iterable * @throws IllegalArgumentException if maxSize is negative */ public FluentIterable<E> limit(final long maxSize) { return of(IterableUtils.boundedIterable(iterable, maxSize)); }
/** * Returns a new FluentIterable whose iterator will traverse the * elements from this iterable in reverse order. * * @return a new iterable, providing a reversed view of this iterable */ public FluentIterable<E> reverse() { return of(IterableUtils.reversedIterable(iterable)); }
/** * Returns a new FluentIterable whose iterator will return an unmodifiable * view of this iterable. * * @return a new iterable, providing an unmodifiable view of this iterable */ public FluentIterable<E> unmodifiable() { return of(IterableUtils.unmodifiableIterable(iterable)); }
/** * Returns a new FluentIterable whose iterator will traverse * the elements of this iterable and the other iterable in * alternating order. * * @param other the other iterable to interleave, may not be null * @return a new iterable, interleaving this iterable with others * @throws NullPointerException if other is null */ public FluentIterable<E> zip(final Iterable<? extends E> other) { return of(IterableUtils.zippingIterable(iterable, other)); }
/** * Returns a new FluentIterable whose iterator will first traverse * the elements of the current iterable, followed by the elements * of the provided iterable. * * @param other the other iterable to combine, may not be null * @return a new iterable, combining this iterable with other * @throws NullPointerException if other is null */ public FluentIterable<E> append(final Iterable<? extends E> other) { return of(IterableUtils.chainedIterable(iterable, other)); }
/** * Returns a new FluentIterable whose iterator will only return * elements from this iterable matching the provided predicate. * * @param predicate the predicate used to filter elements * @return a new iterable, providing a filtered view of this iterable * @throws NullPointerException if predicate is null */ public FluentIterable<E> filter(final Predicate<? super E> predicate) { return of(IterableUtils.filteredIterable(iterable, predicate)); }
/** * Returns a new FluentIterable whose iterator will skip the first * N elements from this iterable. * * @param elementsToSkip the number of elements to skip * @return a new iterable, providing a view of this iterable by skipping * the first N elements * @throws IllegalArgumentException if elementsToSkip is negative */ public FluentIterable<E> skip(final long elementsToSkip) { return of(IterableUtils.skippingIterable(iterable, elementsToSkip)); }
/** * Returns a new FluentIterable whose iterator will return all elements * of this iterable transformed by the provided transformer. * * @param <O> the output element type * @param transformer the transformer applied to each element * @return a new iterable, providing a transformed view of this iterable * @throws NullPointerException if transformer is null */ public <O> FluentIterable<O> transform(final Transformer<? super E, ? extends O> transformer) { return of(IterableUtils.transformedIterable(iterable, transformer)); }
/** * Returns a new FluentIterable whose iterator will loop infinitely * over the elements from this iterable. * * @return a new iterable, providing a looping view of this iterable */ public FluentIterable<E> loop() { return of(IterableUtils.loopingIterable(iterable)); }
/** * Returns a new FluentIterable whose iterator will return a unique view * of this iterable. * * @return a new iterable, providing a unique view of this iterable */ public FluentIterable<E> unique() { return of(IterableUtils.uniqueIterable(iterable)); }
/** * Returns a new FluentIterable whose iterator will traverse * the elements of this iterable and the other iterables in * alternating order. * * @param others the iterables to interleave, may not be null * @return a new iterable, interleaving this iterable with others * @throws NullPointerException if either of the provided iterables is null */ public FluentIterable<E> zip(final Iterable<? extends E>... others) { return of(IterableUtils.zippingIterable(iterable, others)); }
/** * This method fully traverses an iterator of this iterable and returns * a new iterable with the same contents, but without any reference * to the originating iterables and/or iterators. * <p> * Calling this method is equivalent to: * <pre> * FluentIterable<E> someIterable = ...; * FluentIterable.of(someIterable.toList()); * </pre> * * @return a new iterable with the same contents as this iterable */ public FluentIterable<E> eval() { return of(toList()); }
/** * Returns a new FluentIterable whose iterator will traverse the * elements of the current and provided iterable according to the * ordering defined by an comparator. * <p> * Example: descending order * <ul> * <li>this contains elements [7, 5, 3, 1] * <li>other contains elements [8, 6, 4, 2] * </ul> * <p> * The returned iterable will traverse the elements in the following * order: [8, 7, 6, 5, 4, 3, 2, 1] * * @param comparator the comparator to define an ordering, may be null, * in which case natural ordering will be used * @param other the other iterable to collate, may not be null * @return a new iterable, collating this iterable with the other in natural order * @throws NullPointerException if other is null * @see org.apache.commons.collections4.iterators.CollatingIterator */ public FluentIterable<E> collate(final Iterable<? extends E> other, final Comparator<? super E> comparator) { return of(IterableUtils.collatedIterable(comparator, iterable, other)); }
/** * Returns a new FluentIterable whose iterator will traverse the * elements of the current and provided iterable in natural order. * <p> * Example: natural ordering * <ul> * <li>this contains elements [1, 3, 5, 7] * <li>other contains elements [2, 4, 6, 8] * </ul> * <p> * The returned iterable will traverse the elements in the following * order: [1, 2, 3, 4, 5, 6, 7, 8] * * @param other the other iterable to collate, may not be null * @return a new iterable, collating this iterable with the other in natural order * @throws NullPointerException if other is null * @see org.apache.commons.collections4.iterators.CollatingIterator */ public FluentIterable<E> collate(final Iterable<? extends E> other) { return of(IterableUtils.collatedIterable(iterable, other)); }
/** * Constructs a new <code>ZippingIterator</code> that will provide * interleaved iteration of the specified iterators. * * @param iterators the array of iterators * @throws NullPointerException if any iterator is null */ public ZippingIterator(final Iterator<? extends E>... iterators) { // create a mutable list to be able to remove exhausted iterators final List<Iterator<? extends E>> list = new ArrayList<>(); for (final Iterator<? extends E> iterator : iterators) { if (iterator == null) { throw new NullPointerException("Iterator must not be null."); } list.add(iterator); } this.iterators = FluentIterable.of(list).loop().iterator(); }
/** * Creates a new FluentIterable of the single provided element. * <p> * The returned iterable's iterator does not support {@code remove()}. * * @param <T> the element type * @param singleton the singleton element * @return a new FluentIterable containing the singleton */ public static <T> FluentIterable<T> of(final T singleton) { return of(IteratorUtils.asIterable(new SingletonIterator<>(singleton, false))); }
@Override public boolean putAll(final K key, final Iterable<? extends V> values) { if (values == null) { throw new NullPointerException("Values must not be null."); } final Iterable<V> transformedValues = FluentIterable.of(values).transform(valueTransformer); final Iterator<? extends V> it = transformedValues.iterator(); return it.hasNext() && CollectionUtils.addAll(decorated().get(transformKey(key)), it); }