Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.google.common.collect.Iterables Maven / Gradle / Ivy
Google Collections Library is a suite of new collections and collection-related goodness for Java 5.0
/*
* Copyright (C) 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import com.google.common.base.Function;
import com.google.common.base.Nullable;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkContentsNotNull;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Predicate;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedSet;
/**
* This class contains static utility methods that operate on or return objects
* of type {@code Iterable}. Also see the parallel implementations in {@link
* Iterators}.
*
* @author Kevin Bourrillion
* @author Scott Bonneau
*/
public final class Iterables {
private Iterables() {}
private static final Iterable EMPTY_ITERABLE = new Iterable()
{
public Iterator iterator() {
return Iterators.EMPTY_ITERATOR;
}
};
/** Returns the empty {@code Iterable}. */
// Casting to any type is safe since there are no actual elements.
@SuppressWarnings("unchecked")
public static Iterable emptyIterable() {
return (Iterable) EMPTY_ITERABLE;
}
/** Returns an unmodifiable view of {@code iterable}. */
public static Iterable unmodifiableIterable(final Iterable iterable)
{
checkNotNull(iterable);
return new Iterable() {
public Iterator iterator() {
return Iterators.unmodifiableIterator(iterable.iterator());
}
@Override public String toString() {
return iterable.toString();
}
// no equals and hashCode; it would break the contract!
};
}
/**
* Returns the number of elements in {@code iterable}.
*/
public static int size(Iterable iterable) {
return (iterable instanceof Collection)
? ((Collection) iterable).size()
: Iterators.size(iterable.iterator());
}
/**
* Determines whether two iterables contain equal elements in the same order.
* More specifically, this method returns {@code true} if {@code iterable1}
* and {@code iterable2} contain the same number of elements and every element
* of {@code iterable1} is equal to the corresponding element of
* {@code iterable2}.
*/
public static boolean elementsEqual(
Iterable iterable1, Iterable iterable2) {
return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator());
}
/**
* Returns a string representation of {@code iterable}, with the format
* {@code [e1, e2, ..., en]}.
*/
public static String toString(Iterable iterable) {
return Iterators.toString(iterable.iterator());
}
/**
* Returns the single element contained in {@code iterable}.
*
* @throws NoSuchElementException if the iterable is empty
* @throws IllegalArgumentException if the iterable contains multiple
* elements
*/
public static T getOnlyElement(Iterable iterable) {
return Iterators.getOnlyElement(iterable.iterator());
}
/**
* Returns the single element contained in {@code iterable}, or {@code
* defaultValue} if the iterable is empty.
*
* @throws IllegalArgumentException if the iterator contains multiple
* elements
*/
public static T getOnlyElement(
Iterable iterable, @Nullable T defaultValue) {
return Iterators.getOnlyElement(iterable.iterator(), defaultValue);
}
/**
* Copies an iterable's elements into an array.
*
* @param iterable the iterable to copy
* @param type the type of the elements
* @return a newly-allocated array into which all the elements of the iterable
* have been copied
*/
public static T[] newArray(Iterable iterable, Class type) {
Collection collection = (iterable instanceof Collection)
? (Collection) iterable
: Lists.newArrayList(iterable);
T[] array = ObjectArrays.newArray(type, collection.size());
return collection.toArray(array);
}
/**
* Adds all elements in {@code iterable} to {@code collection}.
*
* @return {@code true} if {@code collection} was modified as a result of this
* operation.
*/
public static boolean addAll(
Collection collection, Iterable iterable) {
if (iterable instanceof Collection) {
@SuppressWarnings("unchecked")
Collection c = (Collection) iterable;
return collection.addAll(c);
}
return Iterators.addAll(collection, iterable.iterator());
}
/**
* Returns the number of elements in the specified iterable that equal the
* specified object.
*
* @see Collections#frequency
*/
public static int frequency(Iterable iterable, @Nullable Object element) {
if ((iterable instanceof Multiset)) {
return ((Multiset) iterable).count(element);
}
if ((iterable instanceof Set)) {
return ((Set) iterable).contains(element) ? 1 : 0;
}
return Iterators.frequency(iterable.iterator(), element);
}
/**
* Returns an iterable whose iterator cycles indefinitely over the elements of
* {@code iterable}.
*
* That iterator supports {@code remove()} if {@code iterable.iterator()}
* does. After {@code remove()} is called, subsequent cycles omit the removed
* element, which is no longer in {@code iterable}. The iterator's
* {@code hasNext()} method returns {@code true} until {@code iterable} is
* empty.
*
*
Warning: Typical uses of the resulting iterator may produce an
* infinite loop. You should use an explicit {@code break} or be certain that
* you will eventually remove all the elements.
*/
public static Iterable cycle(final Iterable iterable) {
checkNotNull(iterable);
return new Iterable() {
public Iterator iterator() {
return Iterators.cycle(iterable);
}
@Override public String toString() {
return iterable.toString() + " (cycled)";
}
};
}
/**
* Returns an iterable whose iterator cycles indefinitely over the provided
* elements.
*
* That iterator supports {@code remove()} if {@code iterable.iterator()}
* does. After {@code remove()} is called, subsequent cycles omit the removed
* element, but {@code elements} does not change. The iterator's
* {@code hasNext()} method returns {@code true} until all of the original
* elements have been removed.
*
*
Warning: Typical uses of the resulting iterator may produce an
* infinite loop. You should use an explicit {@code break} or be certain that
* you will eventually remove all the elements.
*/
public static Iterable cycle(T... elements) {
return cycle(Lists.newArrayList(elements));
}
/**
* Combines two iterables into a single iterable. The returned iterable has an
* iterator that traverses the elements in {@code a}, followed by the elements
* in {@code b}. The source iterators are not polled until necessary.
*
* The returned iterable's iterator supports {@code remove()} when the
* corresponding input iterator supports it.
*/
@SuppressWarnings("unchecked")
public static Iterable concat(
Iterable a, Iterable b) {
checkNotNull(a);
checkNotNull(b);
return concat(Arrays.asList(a, b));
}
/**
* Combines multiple iterables into a single iterable. The returned iterable
* has an iterator that traverses the elements of each iterable in
* {@code inputs}. The input iterators are not polled until necessary.
*
* The returned iterable's iterator supports {@code remove()} when the
* corresponding input iterator supports it.
*
* @throws NullPointerException if any of the provided iterables is null
*/
public static Iterable concat(Iterable... inputs) {
return concat(checkContentsNotNull(Arrays.asList(inputs)));
}
/**
* Combines multiple iterables into a single iterable. The returned iterable
* has an iterator that traverses the elements of each iterable in
* {@code inputs}. The input iterators are not polled until necessary.
*
* The returned iterable's iterator supports {@code remove()} when the
* corresponding input iterator supports it. The methods of the returned
* iterable may throw {@code NullPointerException} if any of the input
* iterators are null.
*/
public static Iterable concat(
Iterable> inputs) {
/*
* Hint: if you let A represent Iterable and B represent
* Iterator, then this Function would look simply like:
*
* Function function = new Function {
* public B apply(A from) {
* return from.iterator();
* }
* }
*
* TODO: there may be a better way to do this.
*/
Function, Iterator> function
= new Function, Iterator>() {
public Iterator apply(Iterable from) {
return from.iterator();
}
};
final Iterable> iterators
= transform(inputs, function);
return new AbstractIterable() {
public Iterator iterator() {
return Iterators.concat(iterators.iterator());
}
};
}
/**
* Partition an iterable into sub-iterables of the given size. For example,
* {A, B, C, D, E, F} with partition size 3 yields
* {A, B, C} and {D, E, F}. The returned iterables
* have iterators that do not support {@code remove()}.
*
* After {@code next()} is called on the returned iterable's iterator, the
* iterables from prior {@code next()} calls become invalid.
*
* @param iterable the iterable to partition
* @param partitionSize the size of each partition
* @param padToSize whether to pad the last partition to the partition size
* with {@code null}.
* @return an iterable across partitioned iterables
*/
public static Iterable> partition(
final Iterable iterable, final int partitionSize,
final boolean padToSize) {
checkNotNull(iterable);
return new AbstractIterable>() {
public Iterator> iterator() {
final Iterator> iterator = Iterators.partition(
iterable.iterator(), partitionSize, padToSize);
return new AbstractIterator>() {
int howFarIn;
@Override protected Iterable computeNext() {
howFarIn++;
if (!iterator.hasNext()) {
return endOfData();
}
return new AbstractIterable() {
Iterator innerIter = iterator.next();
boolean firstIteratorRequest = true;
public Iterator iterator() {
if (firstIteratorRequest) {
firstIteratorRequest = false;
return innerIter;
} else {
Iterator> iterator = Iterators.partition(
iterable.iterator(), partitionSize, padToSize);
for (int i = 0; i < howFarIn; i++) {
innerIter = iterator.next();
}
return innerIter;
}
}
};
}
};
}
};
}
/**
* Returns the elements of {@code unfiltered} that satisfy a predicate. The
* resulting iterable's iterator does not support {@code remove()}.
*/
public static Iterable filter(
final Iterable unfiltered, final Predicate predicate) {
checkNotNull(unfiltered);
checkNotNull(predicate);
return new AbstractIterable() {
public Iterator iterator() {
return Iterators.filter(unfiltered.iterator(), predicate);
}
};
}
/**
* Returns all instances of class {@code type} in {@code unfiltered}. The
* returned iterable has elements whose class is {@code type} or a subclass of
* {@code type}. The returned iterable's iterator does not support
* {@code remove()}.
*
* @param unfiltered an iterable containing objects of any type
* @param type the type of elements desired
* @return an unmodifiable iterable containing all elements of the original
* iterable that were of the requested type
*/
public static Iterable filter(
final Iterable unfiltered, final Class type) {
checkNotNull(unfiltered);
checkNotNull(type);
return new AbstractIterable() {
public Iterator iterator() {
return Iterators.filter(unfiltered.iterator(), type);
}
};
}
/**
* Returns {@code true} if one or more elements in {@code iterable} satisfy
* the predicate.
*/
public static boolean any(
Iterable iterable, Predicate predicate) {
return Iterators.any(iterable.iterator(), predicate);
}
/**
* Returns {@code true} if every element in {@code iterable} satisfies the
* predicate. If {@code iterable} is empty, {@code true} is returned.
*/
public static boolean all(
Iterable iterable, Predicate predicate) {
return Iterators.all(iterable.iterator(), predicate);
}
/**
* Returns the first element in {@code iterable} that satisfies the given
* predicate.
*
* @throws NoSuchElementException if no element in {@code iterable} matches
* the given predicate
*/
public static E find(Iterable iterable,
Predicate predicate) {
return Iterators.find(iterable.iterator(), predicate);
}
/**
* Returns an iterable that applies {@code function} to each element of {@code
* fromIterable}.
*
* The returned iterable's iterator supports {@code remove()} if the
* provided iterator does. After a successful {@code remove()} call,
* {@code fromIterable} no longer contains the corresponding element.
*/
public static Iterable transform(final Iterable fromIterable,
final Function function) {
checkNotNull(fromIterable);
checkNotNull(function);
return new AbstractIterable() {
public Iterator iterator() {
return Iterators.transform(fromIterable.iterator(), function);
}
};
}
/**
* Returns the element at the specified position in an {@link Iterable}.
*
* @param position position of the element to return
* @return the element at the specified position in {@code iterable}
* @throws NoSuchElementException if {@code position} is negative or greater
* than or equal to the size of {@code iterable}
*/
public static T get(Iterable iterable, int position) {
checkNotNull(iterable);
if (position < 0) {
throw new IndexOutOfBoundsException(
"position cannot be negative: " + position);
}
if (iterable instanceof Collection) {
Collection collection = (Collection) iterable;
int size = collection.size();
if (position >= size) {
throw new IndexOutOfBoundsException(String.format(
"position %d must be less than the iterable size %d",
position, size));
}
if (iterable instanceof List) {
List list = (List) iterable;
return list.get(position);
}
}
return Iterators.get(iterable.iterator(), position);
}
/**
* Returns the last element of {@code iterable}.
*
* @return the last element of {@code iterable}
* @throws NoSuchElementException if the iterable has no elements
*/
public static T getLast(Iterable iterable) {
if (iterable instanceof List) {
List list = (List) iterable;
if (list.isEmpty()) {
throw new NoSuchElementException();
}
return list.get(list.size() - 1);
}
if (iterable instanceof SortedSet) {
SortedSet sortedSet = (SortedSet) iterable;
return sortedSet.last();
}
return Iterators.getLast(iterable.iterator());
}
/**
* Returns a view of {@code iterable} that skips its first
* {@code numberToSkip} elements. If {@code iterable} contains fewer than
* {@code numberToSkip} elements, the returned iterable skips all of its
* elements.
*
* Modifications to the underlying {@link Iterable} before a call to
* {@code iterator()} are reflected in the returned iterator. That is, the
* iterator skips the first {@code numberToSkip} elements that exist when the
* {@code Iterator} is created, not when {@code skip()} is called.
*
*
The returned iterable's iterator supports {@code remove()} if the
* iterator of the underlying iterable supports it. Note that it is
* not possible to delete the last skipped element by immediately
* calling {@code remove()} on that iterator, as the {@code Iterator}
* contract states that a call to {@code remove()} before a call to
* {@code next()} will throw an {@link IllegalStateException}.
*/
public static Iterable skip(final Iterable iterable,
final int numberToSkip) {
checkNotNull(iterable);
checkArgument(numberToSkip >= 0, "number to skip cannot be negative");
if (iterable instanceof List) {
final List list = (List) iterable;
return new Iterable() {
public Iterator iterator() {
return (numberToSkip >= list.size())
? Iterators.emptyIterator()
: list.subList(numberToSkip, list.size()).iterator();
}
};
}
return new Iterable() {
public Iterator iterator() {
final Iterator iterator = iterable.iterator();
Iterators.skip(iterator, numberToSkip);
/*
* We can't just return the iterator because an immediate call to its
* remove() method would remove one of the skipped elements instead of
* throwing an IllegalStateException.
*/
return new Iterator() {
boolean atStart = true;
public boolean hasNext() {
return iterator.hasNext();
}
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
try {
return iterator.next();
} finally {
atStart = false;
}
}
public void remove() {
if (atStart) {
throw new IllegalStateException();
}
iterator.remove();
}
};
}
};
}
/**
* Creates an iterable with the first {@code limitSize} elements of the given
* iterable. If the original iterable does not contain that many elements, the
* returned iterator will have the same behavior as the original iterable. The
* returned iterable's iterator supports {@code remove()} if the original
* iterator does.
*
* @param iterable the iterable to limit
* @param limitSize the maximum number of elements in the returned iterator
* @throws IllegalArgumentException if {@code limitSize} is negative
*/
public static Iterable limit(
final Iterable iterable, final int limitSize) {
checkNotNull(iterable);
checkArgument(limitSize >= 0, "limit is negative");
return new AbstractIterable() {
public Iterator iterator() {
return Iterators.limit(iterable.iterator(), limitSize);
}
};
}
// Methods only in Iterables, not in Iterators
/**
* Adapts a list to an iterable with reversed iteration order. It is
* especially useful in foreach-style loops:
*
* List mylist = ...
* for (String str : Iterables.reverse(mylist)) {
* ...
* }
*
* @return an iterable with the same elements as the list, in reverse.
*/
public static Iterable reverse(final List list) {
checkNotNull(list);
return new AbstractIterable() {
public Iterator iterator() {
final ListIterator listIter = list.listIterator(list.size());
return new Iterator() {
public boolean hasNext() {
return listIter.hasPrevious();
}
public T next() {
return listIter.previous();
}
public void remove() {
listIter.remove();
}
};
}
};
}
/**
* Provides a rotated view of a list. Differs from {@link Collections#rotate}
* in that it leaves the underlying list unchanged. Note that this is a
* "live" view of the list that will change as the list changes. However, the
* behavior of an {@link Iterator} retrieved from a rotated view of the list
* is undefined if the list is structurally changed after the iterator is
* retrieved.
*
* @param list the list to return a rotated view of
* @param distance the distance to rotate the list. There are no constraints
* on this value; it may be zero, negative, or greater than {@code
* list.size()}.
* @return a rotated view of the given list
*/
public static Iterable rotate(final List list, final int distance) {
checkNotNull(list);
// If no rotation is requested, just return the original list
if (distance == 0) {
return list;
}
return new AbstractIterable() {
/**
* Determines the actual distance we need to rotate (distance provided
* might be larger than the size of the list or negative).
*/
int calcActualDistance(int size) {
// we already know distance and size are non-zero
int actualDistance = distance % size;
if (actualDistance < 0) {
// distance must have been negative
actualDistance += size;
}
return actualDistance;
}
public Iterator iterator() {
int size = list.size();
if (size <= 1) {
return list.iterator();
}
int actualDistance = calcActualDistance(size);
// lists of a size that go into the distance evenly don't need rotation
if (actualDistance == 0) {
return list.iterator();
}
@SuppressWarnings("unchecked")
Iterable rotated = concat(list.subList(actualDistance, size),
list.subList(0, actualDistance));
return rotated.iterator();
}
};
}
/**
* Returns whether the given iterable contains no elements.
*
* @return {@code true} if the iterable has no elements, {@code false} if the
* iterable has one or more elements
*/
public static boolean isEmpty(Iterable iterable) {
return !iterable.iterator().hasNext();
}
}
