Mega Code Archive
The collection related utilities
<![CDATA[
/* CollectionsX.java
{{IS_NOTE
Purpose:
Description:
History:
2001/09/15 13:46:20, Create, Tom M. Yeh.
}}IS_NOTE
Copyright (C) 2001 Potix Corporation. All Rights Reserved.
{{IS_RIGHT
This program is distributed under GPL Version 3.0 in the hope that
it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.Map;
import java.util.AbstractList;
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Enumeration;
import java.util.NoSuchElementException;
/**
* The collection related utilities.
*
* @author tomyeh
* @see java.util.Collections
*/
public class CollectionsX {
/** An enumeration on top of a collection or iterator.
*/
public static final class CollectionEnumeration implements Enumeration {
private final Iterator _iter;
public CollectionEnumeration(Collection c) {
this(c != null ? c.iterator(): null);
}
public CollectionEnumeration(Iterator iter) {
_iter = iter;
}
public final boolean hasMoreElements() {
return _iter != null && _iter.hasNext();
}
public final Object nextElement() {
if (_iter != null)
return _iter.next();
throw new NoSuchElementException();
}
}
/** An enumeration on top of an array.
*/
public static final class ArrayEnumeration implements Enumeration {
private final Object[] _ary;
private int _cursor = 0;
public ArrayEnumeration(Object[] ary) {
_ary = ary;
}
public final boolean hasMoreElements() {
return _ary != null && _cursor < _ary.length;
}
public final Object nextElement() {
if (hasMoreElements())
return _ary[_cursor++];
throw new NoSuchElementException();
}
}
/** An enumeration that enumerates one element.
*/
public static final class OneEnumeration implements Enumeration {
private boolean _nomore;
private final Object _one;
public OneEnumeration(Object one) {
_one = one;
}
public final boolean hasMoreElements() {
return !_nomore;
}
public final Object nextElement() {
if (_nomore)
throw new NoSuchElementException();
_nomore = true;
return _one;
}
}
/** An readonly collection on top of an array.
*/
public static final class ArrayCollection extends AbstractCollection {
private final Object[] _ary;
public ArrayCollection(Object[] ary) {
_ary = ary;
}
public final int size() {
return _ary != null ? _ary.length: 0;
}
public Iterator iterator() {
return new ArrayIterator(_ary);
}
}
/** An readonly list on top of an array.
*/
public static final class ArrayList extends AbstractList {
private final Object[] _ary;
public ArrayList(Object[] ary) {
_ary = ary;
}
public final int size() {
return _ary != null ? _ary.length: 0;
}
public final Object get(int index) {
return _ary[index];
}
}
/** An iterator on top of an array.
*/
public static class ArrayIterator implements Iterator {
/*package*/ final Object[] _ary;
/*package*/ int _cursor = 0, _last = -1;
/** @param ary an array or null. */
public ArrayIterator(Object[] ary) {
_ary = ary;
}
public final boolean hasNext() {
return _ary != null && _cursor < _ary.length;
}
public final Object next() {
if (hasNext())
return _ary[_last = _cursor++];
throw new NoSuchElementException("cursor="+_cursor);
}
public final void remove() {
throw new UnsupportedOperationException();
}
}
public static class ArrayListIterator extends ArrayIterator
implements ListIterator {
/** @param ary an array or null. */
public ArrayListIterator(Object[] ary) {
super(ary);
}
/** @param ary an array or null. */
public ArrayListIterator(Object[] ary, int index) {
super(ary);
_cursor = index;
final int len = _ary != null ? _ary.length: 0;
if (_cursor < 0 || _cursor > len)
throw new IndexOutOfBoundsException("index="+index+" but len="+len);
}
public final boolean hasPrevious() {
return _ary != null && _cursor > 0;
}
public final Object previous() {
if (hasPrevious())
return _ary[_last = --_cursor];
throw new NoSuchElementException("cursor="+_cursor);
}
public final int nextIndex() {
return _cursor;
}
public final int previousIndex() {
return _cursor - 1;
}
public final void set(Object o) {
if (_last < 0)
throw new IllegalStateException("neither next nor previous have been called");
_ary[_last] = o;
}
public final void add(Object o) {
throw new UnsupportedOperationException();
}
}
/** A collection that contains only one element.
*/
public static final class OneCollection extends AbstractCollection {
private final Object _one;
public OneCollection(Object one) {
_one = one;
}
public final int size() {
return 1;
}
public Iterator iterator() {
return new OneIterator(_one);
}
}
/** An iterator that iterates one element.
*/
public static final class OneIterator implements Iterator {
private boolean _nomore;
private final Object _one;
public OneIterator(Object one) {
_one = one;
}
public final boolean hasNext() {
return !_nomore;
}
public final Object next() {
if (_nomore)
throw new NoSuchElementException();
_nomore = true;
return _one;
}
public final void remove() {
throw new UnsupportedOperationException();
}
}
/** An iterator that iterates thru an Enumeration.
*/
public static final class EnumerationIterator implements Iterator {
private final Enumeration _enm;
/**
* @param enm the enumeration. If null, it means empty.
*/
public EnumerationIterator(Enumeration enm) {
_enm = enm;
}
public final boolean hasNext() {
return _enm != null && _enm.hasMoreElements();
}
public final Object next() {
if (_enm == null)
throw new NoSuchElementException();
return _enm.nextElement();
}
public final void remove() {
throw new UnsupportedOperationException();
}
};
/** Empty iterator.
*/
public static final Iterator EMPTY_ITERATOR =
new Iterator() {
public final boolean hasNext() {
return false;
}
public final Object next() {
throw new NoSuchElementException();
}
public final void remove() {
throw new IllegalStateException();
}
};
/** Empty enumeration.
*/
public static final Enumeration EMPTY_ENUMERATION =
new Enumeration() {
public final boolean hasMoreElements() {
return false;
}
public final Object nextElement() {
throw new NoSuchElementException();
}
};
/**
* Returns the specified range of the specified collection into a new array.
* The initial index of the range (<tt>from</tt>) must lie between zero
* and <tt>col.size</tt>, inclusive.
* The final index of the range (<tt>to</tt>), which must be greater than or
* equal to <tt>from</tt>.
* <p>The returned array will be "safe" in that no references to it are
* maintained by this list. (In other words, this method must allocate
* a new array). The caller is thus free to modify the returned array.
*
* <p>This method acts as bridge between array-based and collection-based
* APIs.
* @param col the collection to be copied.
* @param from the initial index of the range to be copied, inclusive.
* @param to the final index of the range to be copied, exclusive.
* @since 3.0.6
*/
public static final Object[] toArray(Collection col, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
Object[] result = new Object[newLength];
int i = 0, j = 0;
for (Iterator it = col.iterator(); it.hasNext() && i < result.length;) {
if (j++ < from) {
it.next();
continue;
}
result[i++] = it.next();
}
return result;
}
/** Adds all elements returned by the iterator to a collection.
* @param iter the iterator; null is OK
* @return the number element being added
*/
public static final int addAll(Collection col, Iterator iter) {
int cnt = 0;
if (iter != null)
for (; iter.hasNext(); ++cnt)
col.add(iter.next());
return cnt;
}
/** Adds all elements returned by the enumerator to a collection.
* @param enm the enumeration; null is OK
* @return the number element being added
*/
public static final int addAll(Collection col, Enumeration enm) {
int cnt = 0;
if (enm != null)
for (; enm.hasMoreElements(); ++cnt)
col.add(enm.nextElement());
return cnt;
}
/** Adds all elements of an array to a collection.
* @param ary the array; null is OK
* @return the number element being added
*/
public static final int addAll(Collection col, Object[] ary) {
int cnt = 0;
if (ary != null)
for (; cnt < ary.length; ++cnt)
col.add(ary[cnt]);
return cnt;
}
/** Tests whether two sets has any intersection.
*/
public static final boolean isIntersected(Set a, Set b) {
final int sza = a != null ? a.size(): 0;
final int szb = b != null ? b.size(): 0;
if (sza == 0 || szb == 0)
return false;
final Set large, small;
if (sza > szb) {
large = a;
small = b;
} else {
large = b;
small = a;
}
for (final Iterator it = small.iterator(); it.hasNext();)
if (large.contains(it.next()))
return true;
return false;
}
/**
* Based on the given collection type of Object, return an iterator. The
* Collection type of object can be Collection, Map (return the entry), or
* Array.
*/
public static final Iterator iterator(Object obj) {
if (obj instanceof Object[]) {
return new ArrayIterator((Object[])obj);
} else if (obj instanceof Collection) {
return ((Collection)obj).iterator();
} else if (obj instanceof Map) {
return ((Map)obj).entrySet().iterator();
}
throw new IllegalArgumentException("obj must be a Collection, a Map, or an Object array. obj: "+obj);
}
}
]]>