com.groupbyinc.common.apache.commons.collections4.IteratorUtils Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.collections4;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.collections4.functors.EqualPredicate;
import org.apache.commons.collections4.iterators.ArrayIterator;
import org.apache.commons.collections4.iterators.ArrayListIterator;
import org.apache.commons.collections4.iterators.BoundedIterator;
import org.apache.commons.collections4.iterators.CollatingIterator;
import org.apache.commons.collections4.iterators.EmptyIterator;
import org.apache.commons.collections4.iterators.EmptyListIterator;
import org.apache.commons.collections4.iterators.EmptyMapIterator;
import org.apache.commons.collections4.iterators.EmptyOrderedIterator;
import org.apache.commons.collections4.iterators.EmptyOrderedMapIterator;
import org.apache.commons.collections4.iterators.EnumerationIterator;
import org.apache.commons.collections4.iterators.FilterIterator;
import org.apache.commons.collections4.iterators.FilterListIterator;
import org.apache.commons.collections4.iterators.IteratorChain;
import org.apache.commons.collections4.iterators.IteratorEnumeration;
import org.apache.commons.collections4.iterators.IteratorIterable;
import org.apache.commons.collections4.iterators.ListIteratorWrapper;
import org.apache.commons.collections4.iterators.LoopingIterator;
import org.apache.commons.collections4.iterators.LoopingListIterator;
import org.apache.commons.collections4.iterators.NodeListIterator;
import org.apache.commons.collections4.iterators.ObjectArrayIterator;
import org.apache.commons.collections4.iterators.ObjectArrayListIterator;
import org.apache.commons.collections4.iterators.ObjectGraphIterator;
import org.apache.commons.collections4.iterators.PeekingIterator;
import org.apache.commons.collections4.iterators.PushbackIterator;
import org.apache.commons.collections4.iterators.SingletonIterator;
import org.apache.commons.collections4.iterators.SingletonListIterator;
import org.apache.commons.collections4.iterators.SkippingIterator;
import org.apache.commons.collections4.iterators.TransformIterator;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
import org.apache.commons.collections4.iterators.UnmodifiableListIterator;
import org.apache.commons.collections4.iterators.UnmodifiableMapIterator;
import org.apache.commons.collections4.iterators.ZippingIterator;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* Provides static utility methods and decorators for {@link Iterator}
* instances. The implementations are provided in the iterators subpackage.
*
* @since 2.1
* @version $Id: IteratorUtils.java 1715973 2015-11-23 21:42:01Z tn $
*/
public class IteratorUtils {
// validation is done in this class in certain cases because the
// public classes allow invalid states
/**
* An iterator over no elements.
*/
@SuppressWarnings("rawtypes")
public static final ResettableIterator EMPTY_ITERATOR = EmptyIterator.RESETTABLE_INSTANCE;
/**
* A list iterator over no elements.
*/
@SuppressWarnings("rawtypes")
public static final ResettableListIterator EMPTY_LIST_ITERATOR = EmptyListIterator.RESETTABLE_INSTANCE;
/**
* An ordered iterator over no elements.
*/
@SuppressWarnings("rawtypes")
public static final OrderedIterator EMPTY_ORDERED_ITERATOR = EmptyOrderedIterator.INSTANCE;
/**
* A map iterator over no elements.
*/
@SuppressWarnings("rawtypes")
public static final MapIterator EMPTY_MAP_ITERATOR = EmptyMapIterator.INSTANCE;
/**
* An ordered map iterator over no elements.
*/
@SuppressWarnings("rawtypes")
public static final OrderedMapIterator EMPTY_ORDERED_MAP_ITERATOR = EmptyOrderedMapIterator.INSTANCE;
/**
* Default prefix used while converting an Iterator to its String representation.
*/
private static final String DEFAULT_TOSTRING_PREFIX = "[";
/**
* Default suffix used while converting an Iterator to its String representation.
*/
private static final String DEFAULT_TOSTRING_SUFFIX = "]";
/**
* Default delimiter used to delimit elements while converting an Iterator
* to its String representation.
*/
private static final String DEFAULT_TOSTRING_DELIMITER = ", ";
/**
* IteratorUtils is not normally instantiated.
*/
private IteratorUtils() {}
// Empty
//-----------------------------------------------------------------------
/**
* Gets an empty iterator.
*
* This iterator is a valid iterator object that will iterate over nothing.
*
* @param the element type
* @return an iterator over nothing
*/
public static ResettableIterator emptyIterator() {
return EmptyIterator.resettableEmptyIterator();
}
/**
* Gets an empty list iterator.
*
* This iterator is a valid list iterator object that will iterate
* over nothing.
*
* @param the element type
* @return a list iterator over nothing
*/
public static ResettableListIterator emptyListIterator() {
return EmptyListIterator.resettableEmptyListIterator();
}
/**
* Gets an empty ordered iterator.
*
* This iterator is a valid iterator object that will iterate
* over nothing.
*
* @param the element type
* @return an ordered iterator over nothing
*/
public static OrderedIterator emptyOrderedIterator() {
return EmptyOrderedIterator.emptyOrderedIterator();
}
/**
* Gets an empty map iterator.
*
* This iterator is a valid map iterator object that will iterate
* over nothing.
*
* @param the key type
* @param the value type
* @return a map iterator over nothing
*/
public static MapIterator emptyMapIterator() {
return EmptyMapIterator.emptyMapIterator();
}
/**
* Gets an empty ordered map iterator.
*
* This iterator is a valid map iterator object that will iterate
* over nothing.
*
* @param the key type
* @param the value type
* @return a map iterator over nothing
*/
public static OrderedMapIterator emptyOrderedMapIterator() {
return EmptyOrderedMapIterator.emptyOrderedMapIterator();
}
// Singleton
//-----------------------------------------------------------------------
/**
* Gets a singleton iterator.
*
* This iterator is a valid iterator object that will iterate over
* the specified object.
*
* @param the element type
* @param object the single object over which to iterate
* @return a singleton iterator over the object
*/
public static ResettableIterator singletonIterator(final E object) {
return new SingletonIterator(object);
}
/**
* Gets a singleton list iterator.
*
* This iterator is a valid list iterator object that will iterate over
* the specified object.
*
* @param the element type
* @param object the single object over which to iterate
* @return a singleton list iterator over the object
*/
public static ListIterator singletonListIterator(final E object) {
return new SingletonListIterator(object);
}
// Arrays
//-----------------------------------------------------------------------
/**
* Gets an iterator over an object array.
*
* @param the element type
* @param array the array over which to iterate
* @return an iterator over the array
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final E... array) {
return new ObjectArrayIterator(array);
}
/**
* Gets an iterator over an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @return an iterator over the array
* @throws IllegalArgumentException if the array is not an array
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final Object array) {
return new ArrayIterator(array);
}
/**
* Gets an iterator over the end part of an object array.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @return an iterator over part of the array
* @throws IndexOutOfBoundsException if start is less than zero or greater
* than the length of the array
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final E[] array, final int start) {
return new ObjectArrayIterator(array, start);
}
/**
* Gets an iterator over the end part of an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @return an iterator over part of the array
* @throws IllegalArgumentException if the array is not an array
* @throws IndexOutOfBoundsException if start is less than zero or greater
* than the length of the array
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final Object array, final int start) {
return new ArrayIterator(array, start);
}
/**
* Gets an iterator over part of an object array.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @param end the index to finish iterating at
* @return an iterator over part of the array
* @throws IndexOutOfBoundsException if array bounds are invalid
* @throws IllegalArgumentException if end is before start
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final E[] array, final int start, final int end) {
return new ObjectArrayIterator(array, start, end);
}
/**
* Gets an iterator over part of an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @param end the index to finish iterating at
* @return an iterator over part of the array
* @throws IllegalArgumentException if the array is not an array or end is before start
* @throws IndexOutOfBoundsException if array bounds are invalid
* @throws NullPointerException if array is null
*/
public static ResettableIterator arrayIterator(final Object array, final int start, final int end) {
return new ArrayIterator(array, start, end);
}
//-----------------------------------------------------------------------
/**
* Gets a list iterator over an object array.
*
* @param the element type
* @param array the array over which to iterate
* @return a list iterator over the array
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final E... array) {
return new ObjectArrayListIterator(array);
}
/**
* Gets a list iterator over an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @return a list iterator over the array
* @throws IllegalArgumentException if the array is not an array
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final Object array) {
return new ArrayListIterator(array);
}
/**
* Gets a list iterator over the end part of an object array.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @return a list iterator over part of the array
* @throws IndexOutOfBoundsException if start is less than zero
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final E[] array, final int start) {
return new ObjectArrayListIterator(array, start);
}
/**
* Gets a list iterator over the end part of an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @return a list iterator over part of the array
* @throws IllegalArgumentException if the array is not an array
* @throws IndexOutOfBoundsException if start is less than zero
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final Object array, final int start) {
return new ArrayListIterator(array, start);
}
/**
* Gets a list iterator over part of an object array.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @param end the index to finish iterating at
* @return a list iterator over part of the array
* @throws IndexOutOfBoundsException if array bounds are invalid
* @throws IllegalArgumentException if end is before start
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final E[] array, final int start, final int end) {
return new ObjectArrayListIterator(array, start, end);
}
/**
* Gets a list iterator over part of an object or primitive array.
*
* This method will handle primitive arrays as well as object arrays.
* The primitives will be wrapped in the appropriate wrapper class.
*
* @param the element type
* @param array the array over which to iterate
* @param start the index to start iterating at
* @param end the index to finish iterating at
* @return a list iterator over part of the array
* @throws IllegalArgumentException if the array is not an array or end is before start
* @throws IndexOutOfBoundsException if array bounds are invalid
* @throws NullPointerException if array is null
*/
public static ResettableListIterator arrayListIterator(final Object array, final int start, final int end) {
return new ArrayListIterator(array, start, end);
}
// Bounded
//-----------------------------------------------------------------------
/**
* Decorates the specified iterator to return at most the given number
* of elements.
*
* @param the element type
* @param iterator the iterator to decorate
* @param max the maximum number of elements returned by this iterator
* @return a new bounded iterator
* @throws NullPointerException if the iterator is null
* @throws IllegalArgumentException if max is negative
* @since 4.1
*/
public static BoundedIterator boundedIterator(final Iterator iterator, long max) {
return boundedIterator(iterator, 0, max);
}
/**
* Decorates the specified iterator to return at most the given number
* of elements, skipping all elements until the iterator reaches the
* position at {@code offset}.
*
* The iterator is immediately advanced until it reaches the position at
* {@code offset}, incurring O(n) time.
*
* @param the element type
* @param iterator the iterator to decorate
* @param offset the index of the first element of the decorated iterator to return
* @param max the maximum number of elements returned by this iterator
* @return a new bounded iterator
* @throws NullPointerException if the iterator is null
* @throws IllegalArgumentException if either offset or max is negative
* @since 4.1
*/
public static BoundedIterator boundedIterator(final Iterator iterator,
long offset, long max) {
return new BoundedIterator(iterator, offset, max);
}
// Unmodifiable
//-----------------------------------------------------------------------
/**
* Gets an immutable version of an {@link Iterator}. The returned object
* will always throw an {@link UnsupportedOperationException} for
* the {@link Iterator#remove} method.
*
* @param the element type
* @param iterator the iterator to make immutable
* @return an immutable version of the iterator
*/
public static Iterator unmodifiableIterator(final Iterator iterator) {
return UnmodifiableIterator.unmodifiableIterator(iterator);
}
/**
* Gets an immutable version of a {@link ListIterator}. The returned object
* will always throw an {@link UnsupportedOperationException} for
* the {@link Iterator#remove}, {@link ListIterator#add} and
* {@link ListIterator#set} methods.
*
* @param the element type
* @param listIterator the iterator to make immutable
* @return an immutable version of the iterator
*/
public static ListIterator unmodifiableListIterator(final ListIterator listIterator) {
return UnmodifiableListIterator.umodifiableListIterator(listIterator);
}
/**
* Gets an immutable version of a {@link MapIterator}. The returned object
* will always throw an {@link UnsupportedOperationException} for
* the {@link Iterator#remove}, {@link MapIterator#setValue(Object)} methods.
*
* @param the key type
* @param the value type
* @param mapIterator the iterator to make immutable
* @return an immutable version of the iterator
*/
public static MapIterator unmodifiableMapIterator(final MapIterator mapIterator) {
return UnmodifiableMapIterator.unmodifiableMapIterator(mapIterator);
}
// Chained
//-----------------------------------------------------------------------
/**
* Gets an iterator that iterates through two {@link Iterator}s
* one after another.
*
* @param the element type
* @param iterator1 the first iterator to use, not null
* @param iterator2 the second iterator to use, not null
* @return a combination iterator over the iterators
* @throws NullPointerException if either iterator is null
*/
public static Iterator chainedIterator(final Iterator iterator1,
final Iterator iterator2) {
// keep a version with two iterators to avoid the following warning in client code (Java 5 & 6)
// "A generic array of E is created for a varargs parameter"
return new IteratorChain(iterator1, iterator2);
}
/**
* Gets an iterator that iterates through an array of {@link Iterator}s
* one after another.
*
* @param the element type
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators array is null or contains a null
*/
public static Iterator chainedIterator(final Iterator... iterators) {
return new IteratorChain(iterators);
}
/**
* Gets an iterator that iterates through a collections of {@link Iterator}s
* one after another.
*
* @param the element type
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators collection is null or contains a null
* @throws ClassCastException if the iterators collection contains the wrong object type
*/
public static Iterator chainedIterator(final Collection> iterators) {
return new IteratorChain(iterators);
}
// Collated
//-----------------------------------------------------------------------
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of ordered {@link Iterator}s.
*
* Given two ordered {@link Iterator}s A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next().
*
* The comparator is optional. If null is specified then natural order is used.
*
* @param the element type
* @param comparator the comparator to use, may be null for natural order
* @param iterator1 the first iterators to use, not null
* @param iterator2 the first iterators to use, not null
* @return a combination iterator over the iterators
* @throws NullPointerException if either iterator is null
*/
public static Iterator collatedIterator(final Comparator comparator,
final Iterator iterator1,
final Iterator iterator2) {
@SuppressWarnings("unchecked")
final Comparator comp =
comparator == null ? ComparatorUtils.NATURAL_COMPARATOR : (Comparator) comparator;
return new CollatingIterator(comp, iterator1, iterator2);
}
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in an array of {@link Iterator}s.
*
* Given two ordered {@link Iterator}s A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next() and so on.
*
* The comparator is optional. If null is specified then natural order is used.
*
* @param the element type
* @param comparator the comparator to use, may be null for natural order
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators array is null or contains a null value
*/
public static Iterator collatedIterator(final Comparator comparator,
final Iterator... iterators) {
@SuppressWarnings("unchecked")
final Comparator comp =
comparator == null ? ComparatorUtils.NATURAL_COMPARATOR : (Comparator) comparator;
return new CollatingIterator(comp, iterators);
}
/**
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of {@link Iterator}s.
*
* Given two ordered {@link Iterator}s A and B,
* the {@link Iterator#next()} method will return the lesser of
* A.next() and B.next() and so on.
*
* The comparator is optional. If null is specified then natural order is used.
*
* @param the element type
* @param comparator the comparator to use, may be null for natural order
* @param iterators the iterators to use, not null or empty or contain nulls
* @return a combination iterator over the iterators
* @throws NullPointerException if iterators collection is null or contains a null
* @throws ClassCastException if the iterators collection contains the wrong object type
*/
public static Iterator collatedIterator(final Comparator comparator,
final Collection> iterators) {
@SuppressWarnings("unchecked")
final Comparator comp =
comparator == null ? ComparatorUtils.NATURAL_COMPARATOR : (Comparator) comparator;
return new CollatingIterator(comp, iterators);
}
// Object Graph
//-----------------------------------------------------------------------
/**
* Gets an iterator that operates over an object graph.
*
* This iterator can extract multiple objects from a complex tree-like object graph.
* The iteration starts from a single root object.
* It uses a Transformer to extract the iterators and elements.
* Its main benefit is that no intermediate List is created.
*
* For example, consider an object graph:
*
* |- Branch -- Leaf
* | \- Leaf
* |- Tree | /- Leaf
* | |- Branch -- Leaf
* Forest | \- Leaf
* | |- Branch -- Leaf
* | | \- Leaf
* |- Tree | /- Leaf
* |- Branch -- Leaf
* |- Branch -- Leaf
* The following Transformer, used in this class, will extract all
* the Leaf objects without creating a combined intermediate list:
*
* public Object transform(Object input) {
* if (input instanceof Forest) {
* return ((Forest) input).treeIterator();
* }
* if (input instanceof Tree) {
* return ((Tree) input).branchIterator();
* }
* if (input instanceof Branch) {
* return ((Branch) input).leafIterator();
* }
* if (input instanceof Leaf) {
* return input;
* }
* throw new ClassCastException();
* }
*
* Internally, iteration starts from the root object. When next is called,
* the transformer is called to examine the object. The transformer will return
* either an iterator or an object. If the object is an Iterator, the next element
* from that iterator is obtained and the process repeats. If the element is an object
* it is returned.
*
* Under many circumstances, linking Iterators together in this manner is
* more efficient (and convenient) than using nested for loops to extract a list.
*
* @param the element type
* @param root the root object to start iterating from, null results in an empty iterator
* @param transformer the transformer to use, see above, null uses no effect transformer
* @return a new object graph iterator
* @since 3.1
*/
public static Iterator objectGraphIterator(final E root,
final Transformer transformer) {
return new ObjectGraphIterator(root, transformer);
}
// Transformed
//-----------------------------------------------------------------------
/**
* Gets an iterator that transforms the elements of another iterator.
*
* The transformation occurs during the next() method and the underlying
* iterator is unaffected by the transformation.
*
* @param the input type
* @param the output type
* @param iterator the iterator to use, not null
* @param transform the transform to use, not null
* @return a new transforming iterator
* @throws NullPointerException if either parameter is null
*/
public static Iterator transformedIterator(final Iterator iterator,
final Transformer transform) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (transform == null) {
throw new NullPointerException("Transformer must not be null");
}
return new TransformIterator(iterator, transform);
}
// Filtered
//-----------------------------------------------------------------------
/**
* Gets an iterator that filters another iterator.
*
* The returned iterator will only return objects that match the specified
* filtering predicate.
*
* @param the element type
* @param iterator the iterator to use, not null
* @param predicate the predicate to use as a filter, not null
* @return a new filtered iterator
* @throws NullPointerException if either parameter is null
*/
public static Iterator filteredIterator(final Iterator iterator,
final Predicate predicate) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (predicate == null) {
throw new NullPointerException("Predicate must not be null");
}
return new FilterIterator(iterator, predicate);
}
/**
* Gets a list iterator that filters another list iterator.
*
* The returned iterator will only return objects that match the specified
* filtering predicate.
*
* @param the element type
* @param listIterator the list iterator to use, not null
* @param predicate the predicate to use as a filter, not null
* @return a new filtered iterator
* @throws NullPointerException if either parameter is null
*/
public static ListIterator filteredListIterator(final ListIterator listIterator,
final Predicate predicate) {
if (listIterator == null) {
throw new NullPointerException("ListIterator must not be null");
}
if (predicate == null) {
throw new NullPointerException("Predicate must not be null");
}
return new FilterListIterator(listIterator, predicate);
}
// Looping
//-----------------------------------------------------------------------
/**
* Gets an iterator that loops continuously over the supplied collection.
*
* The iterator will only stop looping if the remove method is called
* enough times to empty the collection, or if the collection is empty
* to start with.
*
* @param the element type
* @param coll the collection to iterate over, not null
* @return a new looping iterator
* @throws NullPointerException if the collection is null
*/
public static ResettableIterator loopingIterator(final Collection coll) {
if (coll == null) {
throw new NullPointerException("Collection must not be null");
}
return new LoopingIterator(coll);
}
/**
* Gets an iterator that loops continuously over the supplied list.
*
* The iterator will only stop looping if the remove method is called
* enough times to empty the list, or if the list is empty to start with.
*
* @param the element type
* @param list the list to iterate over, not null
* @return a new looping iterator
* @throws NullPointerException if the list is null
* @since 3.2
*/
public static ResettableListIterator loopingListIterator(final List list) {
if (list == null) {
throw new NullPointerException("List must not be null");
}
return new LoopingListIterator(list);
}
// org.w3c.dom.NodeList iterators
//-----------------------------------------------------------------------
/**
* Gets an {@link Iterator} that wraps the specified {@link NodeList}.
* The returned {@link Iterator} can be used for a single iteration.
*
* @param nodeList the node list to use, may not be null
* @return a new, single use {@link Iterator}
* @throws NullPointerException if nodeList is null
* @since 4.0
*/
public static NodeListIterator nodeListIterator(final NodeList nodeList) {
if (nodeList == null) {
throw new NullPointerException("NodeList must not be null");
}
return new NodeListIterator(nodeList);
}
/**
* Gets an {@link Iterator} that wraps the specified node's childNodes.
* The returned {@link Iterator} can be used for a single iteration.
*
* Convenience method, allows easy iteration over NodeLists:
*
* Iterator<Node> iterator = IteratorUtils.nodeListIterator(node);
* for(Node childNode : IteratorUtils.asIterable(iterator)) {
* ...
* }
*
*
* @param node the node to use, may not be null
* @return a new, single use {@link Iterator}
* @throws NullPointerException if node is null
* @since 4.0
*/
public static NodeListIterator nodeListIterator(final Node node) {
if (node == null) {
throw new NullPointerException("Node must not be null");
}
return new NodeListIterator(node);
}
// Peeking
//-----------------------------------------------------------------------
/**
* Gets an iterator that supports one-element lookahead.
*
* @param the element type
* @param iterator the iterator to decorate, not null
* @return a peeking iterator
* @throws NullPointerException if the iterator is null
* @since 4.0
*/
public static Iterator peekingIterator(final Iterator iterator) {
return PeekingIterator.peekingIterator(iterator);
}
// Pushback
//-----------------------------------------------------------------------
/**
* Gets an iterator that supports pushback of elements.
*
* @param the element type
* @param iterator the iterator to decorate, not null
* @return a pushback iterator
* @throws NullPointerException if the iterator is null
* @since 4.0
*/
public static Iterator pushbackIterator(final Iterator iterator) {
return PushbackIterator.pushbackIterator(iterator);
}
// Skipping
//-----------------------------------------------------------------------
/**
* Decorates the specified iterator to skip the first N elements.
*
* @param the element type
* @param iterator the iterator to decorate
* @param offset the first number of elements to skip
* @return a new skipping iterator
* @throws NullPointerException if the iterator is null
* @throws IllegalArgumentException if offset is negative
* @since 4.1
*/
public static SkippingIterator skippingIterator(final Iterator iterator, long offset) {
return new SkippingIterator(iterator, offset);
}
// Zipping
//-----------------------------------------------------------------------
/**
* Returns an iterator that interleaves elements from the decorated iterators.
*
* @param the element type
* @param a the first iterator to interleave
* @param b the second iterator to interleave
* @return an iterator, interleaving the decorated iterators
* @throws NullPointerException if any iterator is null
* @since 4.1
*/
public static ZippingIterator zippingIterator(final Iterator a,
final Iterator b) {
return new ZippingIterator(a, b);
}
/**
* Returns an iterator that interleaves elements from the decorated iterators.
*
* @param the element type
* @param a the first iterator to interleave
* @param b the second iterator to interleave
* @param c the third iterator to interleave
* @return an iterator, interleaving the decorated iterators
* @throws NullPointerException if any iterator is null
* @since 4.1
*/
public static ZippingIterator zippingIterator(final Iterator a,
final Iterator b,
final Iterator c) {
return new ZippingIterator(a, b, c);
}
/**
* Returns an iterator that interleaves elements from the decorated iterators.
*
* @param the element type
* @param iterators the array of iterators to interleave
* @return an iterator, interleaving the decorated iterators
* @throws NullPointerException if any iterator is null
* @since 4.1
*/
public static ZippingIterator zippingIterator(final Iterator... iterators) {
return new ZippingIterator(iterators);
}
// Views
//-----------------------------------------------------------------------
/**
* Gets an iterator that provides an iterator view of the given enumeration.
*
* @param the element type
* @param enumeration the enumeration to use, may not be null
* @return a new iterator
* @throws NullPointerException if enumeration is null
*/
public static Iterator asIterator(final Enumeration enumeration) {
if (enumeration == null) {
throw new NullPointerException("Enumeration must not be null");
}
return new EnumerationIterator(enumeration);
}
/**
* Gets an iterator that provides an iterator view of the given enumeration
* that will remove elements from the specified collection.
*
* @param the element type
* @param enumeration the enumeration to use, may not be null
* @param removeCollection the collection to remove elements from, may not be null
* @return a new iterator
* @throws NullPointerException if enumeration or removeCollection is null
*/
public static Iterator asIterator(final Enumeration enumeration,
final Collection removeCollection) {
if (enumeration == null) {
throw new NullPointerException("Enumeration must not be null");
}
if (removeCollection == null) {
throw new NullPointerException("Collection must not be null");
}
return new EnumerationIterator(enumeration, removeCollection);
}
/**
* Gets an enumeration that wraps an iterator.
*
* @param the element type
* @param iterator the iterator to use, may not be null
* @return a new enumeration
* @throws NullPointerException if iterator is null
*/
public static Enumeration asEnumeration(final Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new IteratorEnumeration(iterator);
}
/**
* Gets an {@link Iterable} that wraps an iterator. The returned {@link Iterable} can be
* used for a single iteration.
*
* @param the element type
* @param iterator the iterator to use, may not be null
* @return a new, single use {@link Iterable}
* @throws NullPointerException if iterator is null
*/
public static Iterable asIterable(final Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new IteratorIterable(iterator, false);
}
/**
* Gets an iterable that wraps an iterator. The returned iterable can be
* used for multiple iterations.
*
* @param the element type
* @param iterator the iterator to use, may not be null
* @return a new, multiple use iterable
* @throws NullPointerException if iterator is null
*/
public static Iterable asMultipleUseIterable(final Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new IteratorIterable(iterator, true);
}
/**
* Gets a list iterator based on a simple iterator.
*
* As the wrapped Iterator is traversed, a LinkedList of its values is
* cached, permitting all required operations of ListIterator.
*
* @param the element type
* @param iterator the iterator to use, may not be null
* @return a new iterator
* @throws NullPointerException if iterator parameter is null
*/
public static ListIterator toListIterator(final Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
return new ListIteratorWrapper(iterator);
}
/**
* Gets an array based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, this is converted to an array.
*
* @param iterator the iterator to use, not null
* @return an array of the iterator contents
* @throws NullPointerException if iterator parameter is null
*/
public static Object[] toArray(final Iterator iterator) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
final List list = toList(iterator, 100);
return list.toArray();
}
/**
* Gets an array based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, this is converted to an array.
*
* @param the element type
* @param iterator the iterator to use, not null
* @param arrayClass the class of array to create
* @return an array of the iterator contents
* @throws NullPointerException if iterator parameter or arrayClass is null
* @throws ArrayStoreException if the arrayClass is invalid
*/
public static E[] toArray(final Iterator iterator, final Class arrayClass) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (arrayClass == null) {
throw new NullPointerException("Array class must not be null");
}
final List list = toList(iterator, 100);
@SuppressWarnings("unchecked")
final E[] array = (E[]) Array.newInstance(arrayClass, list.size());
return list.toArray(array);
}
/**
* Gets a list based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, the list is returned.
*
* @param the element type
* @param iterator the iterator to use, not null
* @return a list of the iterator contents
* @throws NullPointerException if iterator parameter is null
*/
public static List toList(final Iterator iterator) {
return toList(iterator, 10);
}
/**
* Gets a list based on an iterator.
*
* As the wrapped Iterator is traversed, an ArrayList of its values is
* created. At the end, the list is returned.
*
* @param the element type
* @param iterator the iterator to use, not null
* @param estimatedSize the initial size of the ArrayList
* @return a list of the iterator contents
* @throws NullPointerException if iterator parameter is null
* @throws IllegalArgumentException if the size is less than 1
*/
public static List toList(final Iterator iterator, final int estimatedSize) {
if (iterator == null) {
throw new NullPointerException("Iterator must not be null");
}
if (estimatedSize < 1) {
throw new IllegalArgumentException("Estimated size must be greater than 0");
}
final List list = new ArrayList(estimatedSize);
while (iterator.hasNext()) {
list.add(iterator.next());
}
return list;
}
/**
* Gets a suitable Iterator for the given object.
*
* This method can handle objects as follows
*
* - null - empty iterator
*
- Iterator - returned directly
*
- Enumeration - wrapped
*
- Collection - iterator from collection returned
*
- Map - values iterator returned
*
- Dictionary - values (elements) enumeration returned as iterator
*
- array - iterator over array returned
*
- object with iterator() public method accessed by reflection
*
- object - singleton iterator
*
- NodeList - iterator over the list
*
- Node - iterator over the child nodes
*
*
* @param obj the object to convert to an iterator
* @return a suitable iterator, never null
*/
public static Iterator getIterator(final Object obj) {
if (obj == null) {
return emptyIterator();
}
if (obj instanceof Iterator) {
return (Iterator) obj;
}
if (obj instanceof Iterable) {
return ((Iterable) obj).iterator();
}
if (obj instanceof Object[]) {
return new ObjectArrayIterator