Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/CollectionTools.java')
-rw-r--r--common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/CollectionTools.java1977
1 files changed, 0 insertions, 1977 deletions
diff --git a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/CollectionTools.java b/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/CollectionTools.java
deleted file mode 100644
index da0c1d1e8b..0000000000
--- a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/CollectionTools.java
+++ /dev/null
@@ -1,1977 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2005, 2010 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- *
- * Contributors:
- * Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.common.utility.internal;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Enumeration;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Random;
-import java.util.RandomAccess;
-import java.util.TreeSet;
-import java.util.Vector;
-
-import org.eclipse.jpt.common.utility.internal.iterables.ArrayIterable;
-import org.eclipse.jpt.common.utility.internal.iterators.ArrayIterator;
-import org.eclipse.jpt.common.utility.internal.iterators.ArrayListIterator;
-import org.eclipse.jpt.common.utility.internal.iterators.SingleElementIterator;
-import org.eclipse.jpt.common.utility.internal.iterators.SingleElementListIterator;
-import org.eclipse.jpt.common.utility.internal.iterators.SuperIteratorWrapper;
-
-/**
- * {@link Collection}-related utility methods.
- */
-public final class CollectionTools {
-
- // ********** add all **********
-
- /**
- * Add all the elements returned by the specified iterable
- * to the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.addAll(Iterable iterable)</code>
- */
- public static <E> boolean addAll(Collection<? super E> collection, Iterable<? extends E> iterable) {
- return addAll(collection, iterable.iterator());
- }
-
- /**
- * Add all the elements returned by the specified iterable
- * to the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.addAll(Iterable iterable)</code>
- */
- public static <E> boolean addAll(Collection<? super E> collection, Iterable<? extends E> iterable, int size) {
- return addAll(collection, iterable.iterator(), size);
- }
-
- /**
- * Add all the elements returned by the specified iterator
- * to the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.addAll(Iterator iterator)</code>
- */
- public static <E> boolean addAll(Collection<? super E> collection, Iterator<? extends E> iterator) {
- return iterator.hasNext() ? addAll_(collection, iterator) : false;
- }
-
- /**
- * assume the iterator is not empty
- */
- private static <E> boolean addAll_(Collection<? super E> collection, Iterator<? extends E> iterator) {
- boolean modified = false;
- while (iterator.hasNext()) {
- modified |= collection.add(iterator.next());
- }
- return modified;
- }
-
- /**
- * Add all the elements returned by the specified iterator
- * to the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.addAll(Iterator iterator)</code>
- */
- public static <E> boolean addAll(Collection<? super E> collection, Iterator<? extends E> iterator, int size) {
- return iterator.hasNext() ? collection.addAll(list(iterator, size)) : false;
- }
-
- /**
- * Add all the elements in the specified array
- * to the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.addAll(Object[] array)</code>
- */
- public static <E> boolean addAll(Collection<? super E> collection, E... array) {
- return (array.length == 0) ? false : addAll_(collection, array);
- }
-
- /**
- * assume the array is not empty
- */
- private static <E> boolean addAll_(Collection<? super E> collection, E... array) {
- boolean modified = false;
- for (E element : array) {
- modified |= collection.add(element);
- }
- return modified;
- }
-
- /**
- * Add all the elements returned by the specified iterable
- * to the specified list at the specified index.
- * Return whether the list changed as a result.
- * <p>
- * <code>List.addAll(Iterable iterable)</code>
- */
- public static <E> boolean addAll(List<? super E> list, int index, Iterable<E> iterable) {
- return addAll(list, index, iterable.iterator());
- }
-
- /**
- * Add all the elements returned by the specified iterable
- * to the specified list at the specified index.
- * Return whether the list changed as a result.
- * <p>
- * <code>List.addAll(Iterable iterable)</code>
- */
- public static <E> boolean addAll(List<? super E> list, int index, Iterable<E> iterable, int size) {
- return addAll(list, index, iterable.iterator(), size);
- }
-
- /**
- * Add all the elements returned by the specified iterator
- * to the specified list at the specified index.
- * Return whether the list changed as a result.
- * <p>
- * <code>List.addAll(Iterator iterator)</code>
- */
- public static <E> boolean addAll(List<? super E> list, int index, Iterator<? extends E> iterator) {
- return iterator.hasNext() ? list.addAll(index, list(iterator)) : false;
- }
-
- /**
- * Add all the elements returned by the specified iterator
- * to the specified list at the specified index.
- * Return whether the list changed as a result.
- * <p>
- * <code>List.addAll(Iterator iterator)</code>
- */
- public static <E> boolean addAll(List<? super E> list, int index, Iterator<? extends E> iterator, int size) {
- return iterator.hasNext() ? list.addAll(index, list(iterator, size)) : false;
- }
-
- /**
- * Add all the elements in the specified array
- * to the specified list at the specified index.
- * Return whether the list changed as a result.
- * <p>
- * <code>List.addAll(Object[] array)</code>
- */
- public static <E> boolean addAll(List<? super E> list, int index, E... array) {
- return (array.length == 0) ? false : list.addAll(index, Arrays.asList(array));
- }
-
-
- // ********** bag **********
-
- /**
- * Return a bag corresponding to the specified enumeration.
- * <p>
- * <code>HashBag(Enumeration enumeration)</code>
- */
- public static <E> HashBag<E> bag(Enumeration<? extends E> enumeration) {
- return bag(enumeration, new HashBag<E>());
- }
-
- /**
- * Return a bag corresponding to the specified enumeration.
- * The specified enumeration size is a performance hint.
- * <p>
- * <code>HashBag(Enumeration enumeration)</code>
- */
- public static <E> HashBag<E> bag(Enumeration<? extends E> enumeration, int enumerationSize) {
- return bag(enumeration, new HashBag<E>(enumerationSize));
- }
-
- private static <E> HashBag<E> bag(Enumeration<? extends E> enumeration, HashBag<E> bag) {
- while (enumeration.hasMoreElements()) {
- bag.add(enumeration.nextElement());
- }
- return bag;
- }
-
- /**
- * Return a bag corresponding to the specified iterable.
- * <p>
- * <code>HashBag(Iterable iterable)</code>
- */
- public static <E> HashBag<E> bag(Iterable<? extends E> iterable) {
- return bag(iterable.iterator());
- }
-
- /**
- * Return a bag corresponding to the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>HashBag(Iterable iterable)</code>
- */
- public static <E> HashBag<E> bag(Iterable<? extends E> iterable, int iterableSize) {
- return bag(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a bag corresponding to the specified iterator.
- * <p>
- * <code>HashBag(Iterator iterator)</code>
- */
- public static <E> HashBag<E> bag(Iterator<? extends E> iterator) {
- return bag(iterator, new HashBag<E>());
- }
-
- /**
- * Return a bag corresponding to the specified iterator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>HashBag(Iterator iterator)</code>
- */
- public static <E> HashBag<E> bag(Iterator<? extends E> iterator, int iteratorSize) {
- return bag(iterator, new HashBag<E>(iteratorSize));
- }
-
- private static <E> HashBag<E> bag(Iterator<? extends E> iterator, HashBag<E> bag) {
- while (iterator.hasNext()) {
- bag.add(iterator.next());
- }
- return bag;
- }
-
- /**
- * Return a bag corresponding to the specified array.
- * <p>
- * <code>HashBag(Object[] array)</code>
- */
- public static <E> HashBag<E> bag(E... array) {
- int len = array.length;
- HashBag<E> bag = new HashBag<E>(len);
- for (E item : array) {
- bag.add(item);
- }
- return bag;
- }
-
-
- // ********** collection **********
-
- /**
- * Return a collection corresponding to the specified enumeration.
- */
- public static <E> HashBag<E> collection(Enumeration<? extends E> enumeration) {
- return bag(enumeration);
- }
-
- /**
- * Return a collection corresponding to the specified enumeration.
- * The specified enumeration size is a performance hint.
- */
- public static <E> HashBag<E> collection(Enumeration<? extends E> enumeration, int enumerationSize) {
- return bag(enumeration, enumerationSize);
- }
-
- /**
- * Return a collection corresponding to the specified iterable.
- */
- public static <E> HashBag<E> collection(Iterable<? extends E> iterable) {
- return collection(iterable.iterator());
- }
-
- /**
- * Return a collection corresponding to the specified iterable.
- * The specified iterable size is a performance hint.
- */
- public static <E> HashBag<E> collection(Iterable<? extends E> iterable, int iterableSize) {
- return collection(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a collection corresponding to the specified iterator.
- */
- public static <E> HashBag<E> collection(Iterator<? extends E> iterator) {
- return bag(iterator);
- }
-
- /**
- * Return a collection corresponding to the specified iterator.
- * The specified iterator size is a performance hint.
- */
- public static <E> HashBag<E> collection(Iterator<? extends E> iterator, int iteratorSize) {
- return bag(iterator, iteratorSize);
- }
-
- /**
- * Return a collection corresponding to the specified array.
- */
- public static <E> HashBag<E> collection(E... array) {
- return bag(array);
- }
-
-
- // ********** contains **********
-
- /**
- * Return whether the specified enumeration contains the
- * specified element.
- * <p>
- * <code>Enumeration.contains(Object o)</code>
- */
- public static boolean contains(Enumeration<?> enumeration, Object value) {
- if (value == null) {
- while (enumeration.hasMoreElements()) {
- if (enumeration.nextElement() == null) {
- return true;
- }
- }
- } else {
- while (enumeration.hasMoreElements()) {
- if (value.equals(enumeration.nextElement())) {
- return true;
- }
- }
- }
- return false;
- }
-
- /**
- * Return whether the specified iterable contains the
- * specified element.
- * <p>
- * <code>Iterable.contains(Object o)</code>
- */
- public static boolean contains(Iterable<?> iterable, Object value) {
- return contains(iterable.iterator(), value);
- }
-
- /**
- * Return whether the specified iterator contains the
- * specified element.
- * <p>
- * <code>Iterator.contains(Object o)</code>
- */
- public static boolean contains(Iterator<?> iterator, Object value) {
- if (value == null) {
- while (iterator.hasNext()) {
- if (iterator.next() == null) {
- return true;
- }
- }
- } else {
- while (iterator.hasNext()) {
- if (value.equals(iterator.next())) {
- return true;
- }
- }
- }
- return false;
- }
-
-
- // ********** contains all **********
-
- /**
- * Return whether the specified collection contains all of the
- * elements in the specified iterable.
- * <p>
- * <code>Collection.containsAll(Iterable iterable)</code>
- */
- public static boolean containsAll(Collection<?> collection, Iterable<?> iterable) {
- return containsAll(collection, iterable.iterator());
- }
-
- /**
- * Return whether the specified collection contains all of the
- * elements in the specified iterator.
- * <p>
- * <code>Collection.containsAll(Iterator iterator)</code>
- */
- public static boolean containsAll(Collection<?> collection, Iterator<?> iterator) {
- while (iterator.hasNext()) {
- if ( ! collection.contains(iterator.next())) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified collection contains all of the
- * elements in the specified array.
- * <p>
- * <code>Collection.containsAll(Object[] array)</code>
- */
- public static boolean containsAll(Collection<?> collection, Object... array) {
- for (int i = array.length; i-- > 0; ) {
- if ( ! collection.contains(array[i])) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified collection.
- * <p>
- * <code>Iterable.containsAll(Collection collection)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, Collection<?> collection) {
- return containsAll(iterable.iterator(), collection);
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified collection.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.containsAll(Collection collection)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, int iterableSize, Collection<?> collection) {
- return containsAll(iterable.iterator(), iterableSize, collection);
- }
-
- /**
- * Return whether the specified iterable 1 contains all of the
- * elements in the specified iterable 2.
- * <p>
- * <code>Iterable.containsAll(Iterable iterable)</code>
- */
- public static boolean containsAll(Iterable<?> iterable1, Iterable<?> iterable2) {
- return containsAll(iterable1.iterator(), iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterable 1 contains all of the
- * elements in the specified iterable 2.
- * The specified iterable 1 size is a performance hint.
- * <p>
- * <code>Iterable.containsAll(Iterable iterable)</code>
- */
- public static boolean containsAll(Iterable<?> iterable1, int iterable1Size, Iterable<?> iterable2) {
- return containsAll(iterable1.iterator(), iterable1Size, iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified iterator.
- * <p>
- * <code>Iterable.containsAll(Iterator iterator)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, Iterator<?> iterator) {
- return containsAll(iterable.iterator(), iterator);
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified iterator.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.containsAll(Iterator iterator)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, int iterableSize, Iterator<?> iterator) {
- return containsAll(iterable.iterator(), iterableSize, iterator);
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified array.
- * <p>
- * <code>Iterable.containsAll(Object[] array)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, Object... array) {
- return containsAll(iterable.iterator(), array);
- }
-
- /**
- * Return whether the specified iterable contains all of the
- * elements in the specified array.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.containsAll(Object[] array)</code>
- */
- public static boolean containsAll(Iterable<?> iterable, int iterableSize, Object... array) {
- return containsAll(iterable.iterator(), iterableSize, array);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified collection.
- * <p>
- * <code>Iterator.containsAll(Collection collection)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, Collection<?> collection) {
- return set(iterator).containsAll(collection);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified collection.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.containsAll(Collection collection)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, int iteratorSize, Collection<?> collection) {
- return set(iterator, iteratorSize).containsAll(collection);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified iterable.
- * <p>
- * <code>Iterator.containsAll(Iterable iterable)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, Iterable<?> iterable) {
- return containsAll(set(iterator), iterable);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified iterable.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.containsAll(Iterable iterable)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, int iteratorSize, Iterable<?> iterable) {
- return containsAll(set(iterator, iteratorSize), iterable);
- }
-
- /**
- * Return whether the specified iterator 1 contains all of the
- * elements in the specified iterator 2.
- * <p>
- * <code>Iterator.containsAll(Iterator iterator)</code>
- */
- public static boolean containsAll(Iterator<?> iterator1, Iterator<?> iterator2) {
- return containsAll(set(iterator1), iterator2);
- }
-
- /**
- * Return whether the specified iterator 1 contains all of the
- * elements in the specified iterator 2.
- * The specified iterator 1 size is a performance hint.
- * <p>
- * <code>Iterator.containsAll(Iterator iterator)</code>
- */
- public static boolean containsAll(Iterator<?> iterator1, int iterator1Size, Iterator<?> iterator2) {
- return containsAll(set(iterator1, iterator1Size), iterator2);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified array.
- * <p>
- * <code>Iterator.containsAll(Object[] array)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, Object... array) {
- return containsAll(set(iterator), array);
- }
-
- /**
- * Return whether the specified iterator contains all of the
- * elements in the specified array.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.containsAll(Object[] array)</code>
- */
- public static boolean containsAll(Iterator<?> iterator, int iteratorSize, Object... array) {
- return containsAll(set(iterator, iteratorSize), array);
- }
-
-
- // ********** diff **********
-
- /**
- * Return the index of the first elements in the specified
- * lists that are different, beginning at the end.
- * If the lists are identical, return -1.
- * If the lists are different sizes, return the index of the
- * last element in the longer list.
- * Use the elements' {@link Object#equals(Object)} method to compare the
- * elements.
- * <p>
- * <code>Collections.diffEnd(List list1, List list2)</code>
- */
- public static int diffEnd(List<?> list1, List<?> list2) {
- return ArrayTools.diffEnd(list1.toArray(), list2.toArray());
- }
-
- /**
- * Return the range of elements in the specified
- * arrays that are different.
- * If the arrays are identical, return [size, -1].
- * Use the elements' {@link Object#equals(Object)} method to compare the
- * elements.
- * <p>
- * <code>Collections.diffRange(List list1, List list2)</code>
- * @see #diffStart(List, List)
- * @see #diffEnd(List, List)
- */
- public static Range diffRange(List<?> list1, List<?> list2) {
- return ArrayTools.diffRange(list1.toArray(), list2.toArray());
- }
-
- /**
- * Return the index of the first elements in the specified
- * lists that are different. If the lists are identical, return
- * the size of the two lists (i.e. one past the last index).
- * If the lists are different sizes and all the elements in
- * the shorter list match their corresponding elements in
- * the longer list, return the size of the shorter list
- * (i.e. one past the last index of the shorter list).
- * Use the elements' {@link Object#equals(Object)} method to compare the
- * elements.
- * <p>
- * <code>Collections.diffStart(List list1, List list2)</code>
- */
- public static int diffStart(List<?> list1, List<?> list2) {
- return ArrayTools.diffStart(list1.toArray(), list2.toArray());
- }
-
-
- // ********** identity diff **********
-
- /**
- * Return the index of the first elements in the specified
- * lists that are different, beginning at the end.
- * If the lists are identical, return -1.
- * If the lists are different sizes, return the index of the
- * last element in the longer list.
- * Use object identity to compare the elements.
- * <p>
- * <code>Collections.identityDiffEnd(List list1, List list2)</code>
- */
- public static int identityDiffEnd(List<?> list1, List<?> list2) {
- return ArrayTools.identityDiffEnd(list1.toArray(), list2.toArray());
- }
-
- /**
- * Return the range of elements in the specified
- * arrays that are different.
- * If the arrays are identical, return [size, -1].
- * Use object identity to compare the elements.
- * <p>
- * <code>Collections.identityDiffStart(List list1, List list2)</code>
- * @see #identityDiffStart(List, List)
- * @see #identityDiffEnd(List, List)
- */
- public static Range identityDiffRange(List<?> list1, List<?> list2) {
- return ArrayTools.identityDiffRange(list1.toArray(), list2.toArray());
- }
-
- /**
- * Return the index of the first elements in the specified
- * lists that are different. If the lists are identical, return
- * the size of the two lists (i.e. one past the last index).
- * If the lists are different sizes and all the elements in
- * the shorter list match their corresponding elements in
- * the longer list, return the size of the shorter list
- * (i.e. one past the last index of the shorter list).
- * Use object identity to compare the elements.
- * <p>
- * <code>Collections.identityDiffStart(List list1, List list2)</code>
- */
- public static int identityDiffStart(List<?> list1, List<?> list2) {
- return ArrayTools.identityDiffStart(list1.toArray(), list2.toArray());
- }
-
-
- // ********** elements are equal **********
-
- /**
- * Return whether the specified iterables do not return the same elements
- * in the same order.
- */
- public static boolean elementsAreDifferent(Iterable<?> iterable1, Iterable<?> iterable2) {
- return elementsAreDifferent(iterable1.iterator(), iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterators do not return the same elements
- * in the same order.
- */
- public static boolean elementsAreDifferent(Iterator<?> iterator1, Iterator<?> iterator2) {
- return ! elementsAreEqual(iterator1, iterator2);
- }
-
- /**
- * Return whether the specified iterables return equal elements
- * in the same order.
- * <p>
- * <code>Iterable.elementsAreEqual(Iterable iterable)</code>
- */
- public static boolean elementsAreEqual(Iterable<?> iterable1, Iterable<?> iterable2) {
- return elementsAreEqual(iterable1.iterator(), iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterators return equal elements
- * in the same order.
- * <p>
- * <code>Iterator.elementsAreEqual(Iterator iterator)</code>
- */
- public static boolean elementsAreEqual(Iterator<?> iterator1, Iterator<?> iterator2) {
- while (iterator1.hasNext() && iterator2.hasNext()) {
- if (Tools.valuesAreDifferent(iterator1.next(), iterator2.next())) {
- return false;
- }
- }
- return ! (iterator1.hasNext() || iterator2.hasNext());
- }
-
-
- // ********** elements are identical **********
-
- /**
- * Return whether the specified iterables return the same elements.
- * <p>
- * <code>Iterable.identical(Iterable iterable)</code>
- */
- public static boolean elementsAreIdentical(Iterable<?> iterable1, Iterable<?> iterable2) {
- return elementsAreIdentical(iterable1.iterator(), iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterators return the same elements.
- * <p>
- * <code>Iterator.identical(Iterator iterator)</code>
- */
- public static boolean elementsAreIdentical(Iterator<?> iterator1, Iterator<?> iterator2) {
- while (iterator1.hasNext() && iterator2.hasNext()) {
- if (iterator1.next() != iterator2.next()) {
- return false;
- }
- }
- return ! (iterator1.hasNext() || iterator2.hasNext());
- }
-
- /**
- * Return whether the specified iterables do <em>not</em> return the same
- * elements.
- * <p>
- * <code>Iterable.notIdentical(Iterable iterable)</code>
- */
- public static boolean elementsAreNotIdentical(Iterable<?> iterable1, Iterable<?> iterable2) {
- return elementsAreNotIdentical(iterable1.iterator(), iterable2.iterator());
- }
-
- /**
- * Return whether the specified iterators do <em>not</em> return the same
- * elements.
- * <p>
- * <code>Iterator.notIdentical(Iterator iterator)</code>
- */
- public static boolean elementsAreNotIdentical(Iterator<?> iterator1, Iterator<?> iterator2) {
- return ! elementsAreIdentical(iterator1, iterator2);
- }
-
-
- // ********** get **********
-
- /**
- * Return the element corresponding to the specified index
- * in the specified iterable.
- * <p>
- * <code>Iterable.get(int index)</code>
- */
- public static <E> E get(Iterable<? extends E> iterable, int index) {
- return get(iterable.iterator(), index);
- }
-
- /**
- * Return the element corresponding to the specified index
- * in the specified iterator.
- * <p>
- * <code>Iterator.get(int index)</code>
- */
- public static <E> E get(Iterator<? extends E> iterator, int index) {
- int i = 0;
- while (iterator.hasNext()) {
- E next = iterator.next();
- if (i++ == index) {
- return next;
- }
- }
- throw new IndexOutOfBoundsException(String.valueOf(index) + ':' + String.valueOf(i));
- }
-
-
- // ********** hash code **********
-
- public static int hashCode(Iterable<?> iterable) {
- if (iterable == null) {
- return 0;
- }
- int hash = 1;
- for (Object element : iterable) {
- hash = 31 * hash + (element == null ? 0 : element.hashCode());
- }
- return hash;
- }
-
-
- // ********** index of **********
-
- /**
- * Return the index of the first occurrence of the
- * specified element in the specified iterable;
- * return -1 if there is no such index.
- * <p>
- * <code>Iterable.indexOf(Object o)</code>
- */
- public static int indexOf(Iterable<?> iterable, Object value) {
- return indexOf(iterable.iterator(), value);
- }
-
- /**
- * Return the index of the first occurrence of the
- * specified element in the specified iterator;
- * return -1 if there is no such index.
- * <p>
- * <code>Iterator.indexOf(Object o)</code>
- */
- public static int indexOf(Iterator<?> iterator, Object value) {
- if (value == null) {
- for (int i = 0; iterator.hasNext(); i++) {
- if (iterator.next() == null) {
- return i;
- }
- }
- } else {
- for (int i = 0; iterator.hasNext(); i++) {
- if (value.equals(iterator.next())) {
- return i;
- }
- }
- }
- return -1;
- }
-
-
- // ********** insertion index of **********
-
- /**
- * Return an index of where the specified comparable object
- * can be inserted into the specified sorted list and still keep
- * the list sorted. If the specified sorted list is an instance of
- * {@link RandomAccess} return the <em>maximum</em> insertion index;
- * otherwise return the <em>minimum</em> insertion index.
- */
- public static <E extends Comparable<? super E>> int insertionIndexOf(List<E> sortedList, Comparable<E> value) {
- if (sortedList instanceof RandomAccess) {
- for (int i = sortedList.size(); i-- > 0; ) {
- if (value.compareTo(sortedList.get(i)) >= 0) {
- return i + 1;
- }
- }
- return 0;
- }
- int i = 0;
- for (E element : sortedList) {
- if (value.compareTo(element) <= 0) {
- return i;
- }
- i++;
- }
- return i;
- }
-
- /**
- * Return an index of where the specified comparable object
- * can be inserted into the specified sorted list and still keep
- * the list sorted. If the specified sorted list is an instance of
- * {@link RandomAccess} return the <em>maximum</em> insertion index;
- * otherwise return the <em>minimum</em> insertion index.
- */
- public static <E> int insertionIndexOf(List<E> sortedList, E value, Comparator<? super E> comparator) {
- if (sortedList instanceof RandomAccess) {
- for (int i = sortedList.size(); i-- > 0; ) {
- if (comparator.compare(value, sortedList.get(i)) >= 0) {
- return i + 1;
- }
- }
- return 0;
- }
- int i = 0;
- for (E element : sortedList) {
- if (comparator.compare(value, element) <= 0) {
- return i;
- }
- i++;
- }
- return i;
- }
-
-
- // ********** iterable/iterator **********
-
- /**
- * Return an iterable on the elements in the specified array.
- * <p>
- * <code>Arrays.iterable(Object[] array)</code>
- */
- public static <E> Iterable<E> iterable(E... array) {
- return new ArrayIterable<E>(array);
- }
-
- /**
- * Return an iterator on the elements in the specified array.
- * <p>
- * <code>Arrays.iterator(Object[] array)</code>
- */
- public static <E> Iterator<E> iterator(E... array) {
- return new ArrayIterator<E>(array);
- }
-
-
- // ********** last **********
-
- /**
- * Return the specified iterable's last element.
- * <p>
- * <code>Iterable.last()</code>
- *
- * @exception java.util.NoSuchElementException iterable is empty.
- */
- public static <E> E last(Iterable<E> iterable) {
- return last(iterable.iterator());
- }
-
- /**
- * Return the specified iterator's last element.
- * <p>
- * <code>Iterator.last()</code>
- *
- * @exception java.util.NoSuchElementException iterator is empty.
- */
- public static <E> E last(Iterator<E> iterator) {
- E last;
- do {
- last = iterator.next();
- } while (iterator.hasNext());
- return last;
- }
-
-
- // ********** last index of **********
-
- /**
- * Return the index of the last occurrence of the
- * specified element in the specified iterable;
- * return -1 if there is no such index.
- * <p>
- * <code>Iterable.lastIndexOf(Object o)
- */
- public static int lastIndexOf(Iterable<?> iterable, Object value) {
- return lastIndexOf(iterable.iterator(), value);
- }
-
- /**
- * Return the index of the last occurrence of the
- * specified element in the specified iterable;
- * return -1 if there is no such index.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.lastIndexOf(Object o)
- */
- public static int lastIndexOf(Iterable<?> iterable, int iterableSize, Object value) {
- return lastIndexOf(iterable.iterator(), iterableSize, value);
- }
-
- /**
- * Return the index of the last occurrence of the
- * specified element in the specified iterator;
- * return -1 if there is no such index.
- * <p>
- * <code>Iterator.lastIndexOf(Object o)
- */
- public static int lastIndexOf(Iterator<?> iterator, Object value) {
- return iterator.hasNext() ? list(iterator).lastIndexOf(value) : -1;
- }
-
- /**
- * Return the index of the last occurrence of the
- * specified element in the specified iterator;
- * return -1 if there is no such index.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.lastIndexOf(Object o)
- */
- public static int lastIndexOf(Iterator<?> iterator, int iteratorSize, Object value) {
- return iterator.hasNext() ? list(iterator, iteratorSize).lastIndexOf(value) : -1;
- }
-
-
- // ********** list **********
-
- /**
- * Return a list corresponding to the specified iterable.
- * <p>
- * <code>Iterable.toList()</code>
- */
- public static <E> ArrayList<E> list(Iterable<? extends E> iterable) {
- return list(iterable.iterator());
- }
-
- /**
- * Return a list corresponding to the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.toList()</code>
- */
- public static <E> ArrayList<E> list(Iterable<? extends E> iterable, int iterableSize) {
- return list(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a list corresponding to the specified iterator.
- * <p>
- * <code>Iterator.toList()</code>
- */
- public static <E> ArrayList<E> list(Iterator<? extends E> iterator) {
- return list(iterator, new ArrayList<E>());
- }
-
- /**
- * Return a list corresponding to the specified iterator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.toList()</code>
- */
- public static <E> ArrayList<E> list(Iterator<? extends E> iterator, int iteratorSize) {
- return list(iterator, new ArrayList<E>(iteratorSize));
- }
-
- private static <E> ArrayList<E> list(Iterator<? extends E> iterator, ArrayList<E> list) {
- while (iterator.hasNext()) {
- list.add(iterator.next());
- }
- return list;
- }
-
- /**
- * Return a list corresponding to the specified array.
- * Unlike {@link Arrays#asList(Object[])}, the list
- * is modifiable and is not backed by the array.
- */
- public static <E> ArrayList<E> list(E... array) {
- return new ArrayList<E>(Arrays.asList(array));
- }
-
- /**
- * Return a list iterator for the specified array.
- * <p>
- * <code>Arrays.listIterator(Object[] array)</code>
- */
- public static <E> ListIterator<E> listIterator(E... array) {
- return listIterator(array, 0);
- }
-
- /**
- * Return a list iterator for the specified array
- * starting at the specified position in the array.
- * <p>
- * <code>Arrays.listIterator(Object[] array, int index)</code>
- */
- public static <E> ListIterator<E> listIterator(E[] array, int start) {
- return listIterator(array, start, array.length - start);
- }
-
- /**
- * Return a list iterator for the specified array
- * starting at the specified position in the array.
- * <p>
- * <code>Arrays.listIterator(Object[] array, int index, int length)</code>
- */
- public static <E> ListIterator<E> listIterator(E[] array, int start, int length) {
- return new ArrayListIterator<E>(array, start, length);
- }
-
-
- // ********** move **********
-
- /**
- * Move an element from the specified source index to the specified target
- * index. Return the altered list.
- * <p>
- * <code>List.move(int targetIndex, int sourceIndex)</code>
- */
- public static <E> List<E> move(List<E> list, int targetIndex, int sourceIndex) {
- return (targetIndex == sourceIndex) ? list : move_(list, targetIndex, sourceIndex);
- }
-
- /**
- * assume targetIndex != sourceIndex
- */
- private static <E> List<E> move_(List<E> list, int targetIndex, int sourceIndex) {
- if (list instanceof RandomAccess) {
- // move elements, leaving the list in place
- E temp = list.get(sourceIndex);
- if (targetIndex < sourceIndex) {
- for (int i = sourceIndex; i-- > targetIndex; ) {
- list.set(i + 1, list.get(i));
- }
- } else {
- for (int i = sourceIndex; i < targetIndex; i++) {
- list.set(i, list.get(i + 1));
- }
- }
- list.set(targetIndex, temp);
- } else {
- // remove the element and re-add it at the target index
- list.add(targetIndex, list.remove(sourceIndex));
- }
- return list;
- }
-
- /**
- * Move elements from the specified source index to the specified target
- * index. Return the altered list.
- * <p>
- * <code>List.move(int targetIndex, int sourceIndex, int length)</code>
- */
- public static <E> List<E> move(List<E> list, int targetIndex, int sourceIndex, int length) {
- if ((targetIndex == sourceIndex) || (length == 0)) {
- return list;
- }
- if (length == 1) {
- return move_(list, targetIndex, sourceIndex);
- }
- if (list instanceof RandomAccess) {
- // move elements, leaving the list in place
- ArrayList<E> temp = new ArrayList<E>(list.subList(sourceIndex, sourceIndex + length));
- if (targetIndex < sourceIndex) {
- for (int i = sourceIndex; i-- > targetIndex; ) {
- list.set(i + length, list.get(i));
- }
- } else {
- for (int i = sourceIndex; i < targetIndex; i++) {
- list.set(i, list.get(i + length));
- }
- }
- for (int i = 0; i < length; i++) {
- list.set(targetIndex + i, temp.get(i));
- }
- } else {
- // remove the elements and re-add them at the target index
- list.addAll(targetIndex, removeElementsAtIndex(list, sourceIndex, length));
- }
- return list;
- }
-
-
- // ********** remove all **********
-
- /**
- * Remove all the elements returned by the specified iterable
- * from the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.removeAll(Iterable iterable)</code>
- */
- public static boolean removeAll(Collection<?> collection, Iterable<?> iterable) {
- return removeAll(collection, iterable.iterator());
- }
-
- /**
- * Remove all the elements returned by the specified iterable
- * from the specified collection.
- * Return whether the collection changed as a result.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Collection.removeAll(Iterable iterable)</code>
- */
- public static boolean removeAll(Collection<?> collection, Iterable<?> iterable, int iterableSize) {
- return removeAll(collection, iterable.iterator(), iterableSize);
- }
-
- /**
- * Remove all the elements returned by the specified iterator
- * from the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.removeAll(Iterator iterator)</code>
- */
- public static boolean removeAll(Collection<?> collection, Iterator<?> iterator) {
- return iterator.hasNext() ? collection.removeAll(set(iterator)) : false;
- }
-
- /**
- * Remove all the elements returned by the specified iterator
- * from the specified collection.
- * Return whether the collection changed as a result.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Collection.removeAll(Iterator iterator)</code>
- */
- public static boolean removeAll(Collection<?> collection, Iterator<?> iterator, int iteratorSize) {
- return iterator.hasNext() ? collection.removeAll(set(iterator, iteratorSize)) : false;
- }
-
- /**
- * Remove all the elements in the specified array
- * from the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.removeAll(Object[] array)</code>
- */
- public static boolean removeAll(Collection<?> collection, Object... array) {
- return (array.length == 0) ? false : collection.removeAll(set(array));
- }
-
-
- // ********** remove all occurrences **********
-
- /**
- * Remove all occurrences of the specified element
- * from the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.removeAllOccurrences(Object value)</code>
- */
- public static boolean removeAllOccurrences(Collection<?> collection, Object value) {
- boolean modified = false;
- Iterator<?> stream = collection.iterator();
- if (value == null) {
- while (stream.hasNext()) {
- if (stream.next() == null) {
- stream.remove();
- modified = true;
- }
- }
- } else {
- while (stream.hasNext()) {
- if (value.equals(stream.next())) {
- stream.remove();
- modified = true;
- }
- }
- }
- return modified;
- }
-
-
- // ********** remove elements at index **********
-
- /**
- * Remove the elements at the specified index.
- * Return the removed elements.
- * <p>
- * <code>List.remove(int index, int length)</code>
- */
- public static <E> ArrayList<E> removeElementsAtIndex(List<E> list, int index, int length) {
- List<E> subList = list.subList(index, index + length);
- ArrayList<E> result = new ArrayList<E>(subList);
- subList.clear();
- return result;
- }
-
-
- // ********** remove duplicate elements **********
-
- /**
- * Remove any duplicate elements from the specified list,
- * while maintaining the order.
- * Return whether the list changed as a result.
- */
- public static <E> boolean removeDuplicateElements(List<E> list) {
- int size = list.size();
- if ((size == 0) || (size == 1)) {
- return false;
- }
- return removeDuplicateElements(list, size);
- }
-
- /**
- * assume list is non-empty
- */
- static <E> boolean removeDuplicateElements(List<E> list, int size) {
- LinkedHashSet<E> temp = new LinkedHashSet<E>(size); // take advantage of hashed look-up
- boolean modified = false;
- for (E item : list) {
- if ( ! temp.add(item)) {
- modified = true; // duplicate item
- }
- }
- if (modified) {
- int i = 0;
- for (E e : temp) {
- list.set(i, e);
- i++;
- }
- int tempSize = temp.size();
- for (i = list.size(); i-- > tempSize; ) {
- list.remove(i); // pull off the end
- }
- }
- return modified;
- }
-
-
- // ********** retain all **********
-
- /**
- * Retain only the elements in the specified iterable
- * in the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.retainAll(Iterable iterable)</code>
- */
- public static boolean retainAll(Collection<?> collection, Iterable<?> iterable) {
- return retainAll(collection, iterable.iterator());
- }
-
- /**
- * Retain only the elements in the specified iterable
- * in the specified collection.
- * Return whether the collection changed as a result.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Collection.retainAll(Iterable iterable)</code>
- */
- public static boolean retainAll(Collection<?> collection, Iterable<?> iterable, int iterableSize) {
- return retainAll(collection, iterable.iterator(), iterableSize);
- }
-
- /**
- * Retain only the elements in the specified iterator
- * in the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.retainAll(Iterator iterator)</code>
- */
- public static boolean retainAll(Collection<?> collection, Iterator<?> iterator) {
- if (iterator.hasNext()) {
- return collection.retainAll(set(iterator));
- }
- if (collection.isEmpty()) {
- return false;
- }
- collection.clear();
- return true;
- }
-
- /**
- * Retain only the elements in the specified iterator
- * in the specified collection.
- * Return whether the collection changed as a result.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Collection.retainAll(Iterator iterator)</code>
- */
- public static boolean retainAll(Collection<?> collection, Iterator<?> iterator, int iteratorSize) {
- if (iterator.hasNext()) {
- return collection.retainAll(set(iterator, iteratorSize));
- }
- if (collection.isEmpty()) {
- return false;
- }
- collection.clear();
- return true;
- }
-
- /**
- * Retain only the elements in the specified array
- * in the specified collection.
- * Return whether the collection changed as a result.
- * <p>
- * <code>Collection.retainAll(Object[] array)</code>
- */
- public static boolean retainAll(Collection<?> collection, Object... array) {
- if (array.length > 0) {
- return collection.retainAll(set(array));
- }
- if (collection.isEmpty()) {
- return false;
- }
- collection.clear();
- return true;
- }
-
-
- // ********** reverse list **********
-
- /**
- * Return a list with entries in reverse order from those
- * returned by the specified iterable.
- * <p>
- * <code>Iterable.reverseList()</code>
- */
- public static <E> ArrayList<E> reverseList(Iterable<? extends E> iterable) {
- return reverseList(iterable.iterator());
- }
-
- /**
- * Return a list with entries in reverse order from those
- * returned by the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.reverseList()</code>
- */
- public static <E> ArrayList<E> reverseList(Iterable<? extends E> iterable, int iterableSize) {
- return reverseList(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a list with entries in reverse order from those
- * returned by the specified iterator.
- * <p>
- * <code>Iterator.reverseList()</code>
- */
- public static <E> ArrayList<E> reverseList(Iterator<? extends E> iterator) {
- return (ArrayList<E>) reverse(list(iterator));
- }
-
- /**
- * Return a list with entries in reverse order from those
- * returned by the specified iterator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.reverseList()</code>
- */
- public static <E> ArrayList<E> reverseList(Iterator<? extends E> iterator, int size) {
- return (ArrayList<E>) reverse(list(iterator, size));
- }
-
-
- // ********** rotate **********
-
- /**
- * Return the list after it has been "rotated" by one position.
- * <p>
- * <code>List.rotate()</code>
- */
- public static <E> List<E> rotate(List<E> list) {
- return rotate(list, 1);
- }
-
-
- // ********** set **********
-
- /**
- * Return a set corresponding to the specified iterable.
- * <p>
- * <code>HashSet(Iterable iterable)</code>
- */
- public static <E> HashSet<E> set(Iterable<? extends E> iterable) {
- return set(iterable.iterator());
- }
-
- /**
- * Return a set corresponding to the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>HashSet(Iterable iterable)</code>
- */
- public static <E> HashSet<E> set(Iterable<? extends E> iterable, int iterableSize) {
- return set(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a set corresponding to the specified iterator.
- * <p>
- * <code>HashSet(Iterator iterator)</code>
- */
- public static <E> HashSet<E> set(Iterator<? extends E> iterator) {
- return set(iterator, new HashSet<E>());
- }
-
- /**
- * Return a set corresponding to the specified iterator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>HashSet(Iterator iterator)</code>
- */
- public static <E> HashSet<E> set(Iterator<? extends E> iterator, int iteratorSize) {
- return set(iterator, new HashSet<E>(iteratorSize));
- }
-
- private static <E> HashSet<E> set(Iterator<? extends E> iterator, HashSet<E> set) {
- while (iterator.hasNext()) {
- set.add(iterator.next());
- }
- return set;
- }
-
- /**
- * Return a set corresponding to the specified array.
- * <p>
- * <code>HashSet(Object[] array)</code>
- */
- public static <E> HashSet<E> set(E... array) {
- HashSet<E> set = new HashSet<E>(array.length);
- for (int i = array.length; i-- > 0;) {
- set.add(array[i]);
- }
- return set;
- }
-
-
- // ********** singleton iterator **********
-
- /**
- * Return an iterator that returns only the single,
- * specified object.
- * <p>
- * <code>Object.toIterator()</code>
- */
- public static <E> Iterator<E> singletonIterator(E value) {
- return new SingleElementIterator<E>(value);
- }
-
- /**
- * Return a list iterator that returns only the single,
- * specified object.
- * <p>
- * <code>Object.toListIterator()</code>
- */
- public static <E> ListIterator<E> singletonListIterator(E value) {
- return new SingleElementListIterator<E>(value);
- }
-
-
- // ********** size **********
-
- /**
- * Return the number of elements returned by the specified iterable.
- * <p>
- * <code>Iterable.size()</code>
- */
- public static int size(Iterable<?> iterable) {
- return size(iterable.iterator());
- }
-
- /**
- * Return the number of elements returned by the specified iterator.
- * <p>
- * <code>Iterator.size()</code>
- */
- public static int size(Iterator<?> iterator) {
- int size = 0;
- while (iterator.hasNext()) {
- iterator.next();
- size++;
- }
- return size;
- }
-
- /**
- * Return whether the specified iterable is empty
- * (Shortcuts the iterator rather than calculating the entire size)
- */
- public static boolean isEmpty(Iterable<?> iterable) {
- return isEmpty(iterable.iterator());
- }
-
- /**
- * Return whether the specified iterator is empty
- * (Shortcuts the iterator rather than calculating the entire size)
- */
- public static boolean isEmpty(Iterator<?> iterator) {
- return ! iterator.hasNext();
- }
-
-
- // ********** sort **********
-
- /**
- * Return an iterable containing the sorted elements of the specified iterable.
- * <p>
- * <code>Iterable.sort()</code>
- */
- public static <E extends Comparable<? super E>> Iterable<E> sort(Iterable<E> iterable) {
- return sort(iterable, null);
- }
-
- /**
- * Return an iterable containing the sorted elements of the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.sort()</code>
- */
- public static <E extends Comparable<? super E>> Iterable<E> sort(Iterable<E> iterable, int iterableSize) {
- return sort(iterable, null, iterableSize);
- }
-
- /**
- * Return an iterable containing the sorted elements of the specified iterable.
- * <p>
- * <code>Iterable.sort(Comparator comparator)</code>
- */
- public static <E> Iterable<E> sort(Iterable<E> iterable, Comparator<? super E> comparator) {
- return sort(list(iterable), comparator);
- }
-
- /**
- * Return an iterable containing the sorted elements of the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>Iterable.sort(Comparator comparator)</code>
- */
- public static <E> Iterable<E> sort(Iterable<E> iterable, Comparator<? super E> comparator, int iterableSize) {
- return sort(list(iterable, iterableSize), comparator);
- }
-
- /**
- * Return the iterator after it has been "sorted".
- * <p>
- * <code>Iterator.sort()</code>
- */
- public static <E extends Comparable<? super E>> ListIterator<E> sort(Iterator<? extends E> iterator) {
- return sort(iterator, null);
- }
-
- /**
- * Return the iterator after it has been "sorted".
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.sort()</code>
- */
- public static <E extends Comparable<? super E>> ListIterator<E> sort(Iterator<? extends E> iterator, int iteratorSize) {
- return sort(iterator, null, iteratorSize);
- }
-
- /**
- * Return the iterator after it has been "sorted".
- * <p>
- * <code>Iterator.sort(Comparator comparator)</code>
- */
- public static <E> ListIterator<E> sort(Iterator<? extends E> iterator, Comparator<? super E> comparator) {
- return sort(list(iterator), comparator).listIterator();
- }
-
- /**
- * Return the iterator after it has been "sorted".
- * The specified iterator size is a performance hint.
- * <p>
- * <code>Iterator.sort(Comparator comparator)</code>
- */
- public static <E> ListIterator<E> sort(Iterator<? extends E> iterator, Comparator<? super E> comparator, int iteratorSize) {
- return sort(list(iterator, iteratorSize), comparator).listIterator();
- }
-
-
- // ********** sorted set **********
-
- /**
- * Return a sorted set corresponding to the specified iterable.
- * <p>
- * <code>TreeSet(Iterable iterable)</code>
- */
- public static <E extends Comparable<? super E>> TreeSet<E> sortedSet(Iterable<? extends E> iterable) {
- return sortedSet(iterable.iterator());
- }
-
- /**
- * Return a sorted set corresponding to the specified iterable.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>TreeSet(Iterable iterable)</code>
- */
- public static <E extends Comparable<? super E>> TreeSet<E> sortedSet(Iterable<? extends E> iterable, int iterableSize) {
- return sortedSet(iterable.iterator(), iterableSize);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterable
- * and comparator.
- * <p>
- * <code>TreeSet(Iterable iterable, Comparator c)</code>
- */
- public static <E> TreeSet<E> sortedSet(Iterable<? extends E> iterable, Comparator<? super E> comparator) {
- return sortedSet(iterable.iterator(), comparator);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterable
- * and comparator.
- * The specified iterable size is a performance hint.
- * <p>
- * <code>TreeSet(Iterable iterable, Comparator c)</code>
- */
- public static <E> TreeSet<E> sortedSet(Iterable<? extends E> iterable, Comparator<? super E> comparator, int iterableSize) {
- return sortedSet(iterable.iterator(), comparator, iterableSize);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterator.
- * <p>
- * <code>TreeSet(Iterator iterator)</code>
- */
- public static <E extends Comparable<? super E>> TreeSet<E> sortedSet(Iterator<? extends E> iterator) {
- return sortedSet(iterator, null);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>TreeSet(Iterator iterator)</code>
- */
- public static <E extends Comparable<? super E>> TreeSet<E> sortedSet(Iterator<? extends E> iterator, int iteratorSize) {
- return sortedSet(iterator, null, iteratorSize);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterator
- * and comparator.
- * <p>
- * <code>TreeSet(Iterator iterator, Comparator c)</code>
- */
- public static <E> TreeSet<E> sortedSet(Iterator<? extends E> iterator, Comparator<? super E> comparator) {
- return sortedSet(list(iterator), comparator);
- }
-
- /**
- * Return a sorted set corresponding to the specified iterator
- * and comparator.
- * The specified iterator size is a performance hint.
- * <p>
- * <code>TreeSet(Iterator iterator, Comparator c)</code>
- */
- public static <E> TreeSet<E> sortedSet(Iterator<? extends E> iterator, Comparator<? super E> comparator, int iteratorSize) {
- return sortedSet(list(iterator, iteratorSize), comparator);
- }
-
- private static <E> TreeSet<E> sortedSet(List<E> list, Comparator<? super E> comparator) {
- TreeSet<E> sortedSet = new TreeSet<E>(comparator);
- sortedSet.addAll(list);
- return sortedSet;
- }
-
- /**
- * Return a sorted set corresponding to the specified array.
- * <p>
- * <code>TreeSet(Object[] array)</code>
- */
- public static <E extends Comparable<? super E>> TreeSet<E> sortedSet(E... array) {
- return sortedSet(array, null);
- }
-
- /**
- * Return a sorted set corresponding to the specified array
- * and comparator.
- * <p>
- * <code>TreeSet(Object[] array, Comparator c)</code>
- */
- public static <E> TreeSet<E> sortedSet(E[] array, Comparator<? super E> comparator) {
- TreeSet<E> sortedSet = new TreeSet<E>(comparator);
- sortedSet.addAll(Arrays.asList(array));
- return sortedSet;
- }
-
-
- // ********** Old School Vector **********
-
- /**
- * Return a vector corresponding to the specified iterable.
- * This is useful for legacy code that requires a {@link Vector}.
- * <p>
- * <code>Vector(Iterable iterable)</code>
- */
- public static <E> Vector<E> vector(Iterable<? extends E> iterable) {
- return vector(iterable.iterator());
- }
-
- /**
- * Return a vector corresponding to the specified iterable.
- * This is useful for legacy code that requires a {@link Vector}.
- * <p>
- * <code>Vector(Iterable iterable, int size)</code>
- */
- public static <E> Vector<E> vector(Iterable<? extends E> iterable, int size) {
- return vector(iterable.iterator(), size);
- }
-
- /**
- * Return a vector corresponding to the specified iterator.
- * This is useful for legacy code that requires a {@link Vector}.
- * <p>
- * <code>Vector(Iterator iterator)</code>
- */
- public static <E> Vector<E> vector(Iterator<? extends E> iterator) {
- return vector(iterator, new Vector<E>());
- }
-
- /**
- * Return a vector corresponding to the specified iterator.
- * This is useful for legacy code that requires a {@link Vector}.
- * <p>
- * <code>Vector(Iterator iterator, int size)</code>
- */
- public static <E> Vector<E> vector(Iterator<? extends E> iterator, int size) {
- return vector(iterator, new Vector<E>(size));
- }
-
- private static <E> Vector<E> vector(Iterator<? extends E> iterator, Vector<E> v) {
- while (iterator.hasNext()) {
- v.addElement(iterator.next());
- }
- return v;
- }
-
- /**
- * Return a vector corresponding to the specified array.
- * This is useful for legacy code that requires a {@link Vector}.
- * <p>
- * <code>Vector(Object... array)</code>
- */
- public static <E> Vector<E> vector(E... array) {
- Vector<E> v = new Vector<E>(array.length);
- for (E item : array) {
- v.addElement(item);
- }
- return v;
- }
-
-
- // ********** single-use Iterable **********
-
- /**
- * Return a one-use {@link Iterable} for the specified {@link Iterator}.
- * Throw an {@link IllegalStateException} if {@link Iterable#iterator()}
- * is called more than once.
- * As such, this utility should only be used in one-use situations, such as
- * a foreach loop.
- */
- public static <E> Iterable<E> iterable(Iterator<? extends E> iterator) {
- return new SingleUseIterable<E>(iterator);
- }
-
- /**
- * This is a one-time use iterable that can return a single iterator.
- * Once the iterator is returned the iterable is no longer valid.
- * As such, this utility should only be used in one-time use situations,
- * such as a 'for-each' loop.
- */
- public static class SingleUseIterable<E> implements Iterable<E> {
- private Iterator<E> iterator;
-
- public SingleUseIterable(Iterator<? extends E> iterator) {
- super();
- if (iterator == null) {
- throw new NullPointerException();
- }
- this.iterator = new SuperIteratorWrapper<E>(iterator);
- }
-
- public Iterator<E> iterator() {
- if (this.iterator == null) {
- throw new IllegalStateException("This method has already been called."); //$NON-NLS-1$
- }
- Iterator<E> result = this.iterator;
- this.iterator = null;
- return result;
- }
-
- @Override
- public String toString() {
- return StringTools.buildToStringFor(this, this.iterator);
- }
-
- }
-
-
- // ********** java.util.Collections enhancements **********
-
- /**
- * Return the destination list after the source list has been copied into it.
- * @see Collections#copy(List, List)
- */
- public static <E> List<E> copy(List<E> dest, List<? extends E> src) {
- Collections.copy(dest, src);
- return dest;
- }
-
- /**
- * Return the list after it has been "filled".
- * @see Collections#fill(List, Object)
- */
- public static <E> List<E> fill(List<E> list, E value) {
- Collections.fill(list, value);
- return list;
- }
-
- /**
- * Return the list after it has been "reversed".
- * @see Collections#reverse(List)
- */
- public static <E> List<E> reverse(List<E> list) {
- Collections.reverse(list);
- return list;
- }
-
- /**
- * Return the list after it has been "rotated".
- * @see Collections#rotate(List, int)
- */
- public static <E> List<E> rotate(List<E> list, int distance) {
- Collections.rotate(list, distance);
- return list;
- }
-
- /**
- * Return the list after it has been "shuffled".
- * @see Collections#shuffle(List)
- */
- public static <E> List<E> shuffle(List<E> list) {
- Collections.shuffle(list);
- return list;
- }
-
- /**
- * Return the list after it has been "shuffled".
- * @see Collections#shuffle(List, Random)
- */
- public static <E> List<E> shuffle(List<E> list, Random random) {
- Collections.shuffle(list, random);
- return list;
- }
-
- /**
- * Return the list after it has been "sorted".
- * NB: The list is sorted in place as a side-effect.
- * @see Collections#sort(List)
- */
- public static <E extends Comparable<? super E>> List<E> sort(List<E> list) {
- Collections.sort(list);
- return list;
- }
-
- /**
- * Return the list after it has been "sorted".
- * NB: The list is sorted in place as a side-effect.
- * @see Collections#sort(List, Comparator)
- */
- public static <E> List<E> sort(List<E> list, Comparator<? super E> comparator) {
- Collections.sort(list, comparator);
- return list;
- }
-
- /**
- * Return the list after the specified elements have been "swapped".
- * @see Collections#swap(List, int, int)
- */
- public static <E> List<E> swap(List<E> list, int i, int j) {
- Collections.swap(list, i, j);
- return list;
- }
-
-
- // ********** constructor **********
-
- /**
- * Suppress default constructor, ensuring non-instantiability.
- */
- private CollectionTools() {
- super();
- throw new UnsupportedOperationException();
- }
-
-}

Back to the top