| Methods Summary |
|---|
| public boolean | add(E e){@inheritDoc}
This implementation always throws an
UnsupportedOperationException.
throw new UnsupportedOperationException();
|
| public boolean | addAll(java.util.Collection c){@inheritDoc}
This implementation iterates over the specified collection, and adds
each object returned by the iterator to this collection, in turn.
Note that this implementation will throw an
UnsupportedOperationException unless add is
overridden (assuming the specified collection is non-empty).
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))
modified = true;
}
return modified;
|
| public void | clear(){@inheritDoc}
This implementation iterates over this collection, removing each
element using the Iterator.remove operation. Most
implementations will probably choose to override this method for
efficiency.
Note that this implementation will throw an
UnsupportedOperationException if the iterator returned by this
collection's iterator method does not implement the
remove method and this collection is non-empty.
Iterator<E> e = iterator();
while (e.hasNext()) {
e.next();
e.remove();
}
|
| public boolean | contains(java.lang.Object o){@inheritDoc}
This implementation iterates over the elements in the collection,
checking each element in turn for equality with the specified element.
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext())
if (e.next()==null)
return true;
} else {
while (e.hasNext())
if (o.equals(e.next()))
return true;
}
return false;
|
| public boolean | containsAll(java.util.Collection c){@inheritDoc}
This implementation iterates over the specified collection,
checking each element returned by the iterator in turn to see
if it's contained in this collection. If all elements are so
contained true is returned, otherwise false.
Iterator<?> e = c.iterator();
while (e.hasNext())
if (!contains(e.next()))
return false;
return true;
|
| private static T[] | finishToArray(T[] r, java.util.Iterator it)Reallocates the array being used within toArray when the iterator
returned more elements than expected, and finishes filling it from
the iterator.
int i = r.length;
while (it.hasNext()) {
int cap = r.length;
if (i == cap) {
int newCap = ((cap / 2) + 1) * 3;
if (newCap <= cap) { // integer overflow
if (cap == Integer.MAX_VALUE)
throw new OutOfMemoryError
("Required array size too large");
newCap = Integer.MAX_VALUE;
}
r = Arrays.copyOf(r, newCap);
}
r[i++] = (T)it.next();
}
// trim if overallocated
return (i == r.length) ? r : Arrays.copyOf(r, i);
|
| public boolean | isEmpty(){@inheritDoc}
This implementation returns size() == 0.
return size() == 0;
|
| public abstract java.util.Iterator | iterator()Returns an iterator over the elements contained in this collection.
|
| public boolean | remove(java.lang.Object o){@inheritDoc}
This implementation iterates over the collection looking for the
specified element. If it finds the element, it removes the element
from the collection using the iterator's remove method.
Note that this implementation throws an
UnsupportedOperationException if the iterator returned by this
collection's iterator method does not implement the remove
method and this collection contains the specified object.
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext()) {
if (e.next()==null) {
e.remove();
return true;
}
}
} else {
while (e.hasNext()) {
if (o.equals(e.next())) {
e.remove();
return true;
}
}
}
return false;
|
| public boolean | removeAll(java.util.Collection c){@inheritDoc}
This implementation iterates over this collection, checking each
element returned by the iterator in turn to see if it's contained
in the specified collection. If it's so contained, it's removed from
this collection with the iterator's remove method.
Note that this implementation will throw an
UnsupportedOperationException if the iterator returned by the
iterator method does not implement the remove method
and this collection contains one or more elements in common with the
specified collection.
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
|
| public boolean | retainAll(java.util.Collection c){@inheritDoc}
This implementation iterates over this collection, checking each
element returned by the iterator in turn to see if it's contained
in the specified collection. If it's not so contained, it's removed
from this collection with the iterator's remove method.
Note that this implementation will throw an
UnsupportedOperationException if the iterator returned by the
iterator method does not implement the remove method
and this collection contains one or more elements not present in the
specified collection.
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
|
| public abstract int | size()
|
| public java.lang.Object[] | toArray(){@inheritDoc}
This implementation returns an array containing all the elements
returned by this collection's iterator, in the same order, stored in
consecutive elements of the array, starting with index {@code 0}.
The length of the returned array is equal to the number of elements
returned by the iterator, even if the size of this collection changes
during iteration, as might happen if the collection permits
concurrent modification during iteration. The {@code size} method is
called only as an optimization hint; the correct result is returned
even if the iterator returns a different number of elements.
This method is equivalent to:
{@code
List list = new ArrayList(size());
for (E e : this)
list.add(e);
return list.toArray();
}
// Estimate size of array; be prepared to see more or fewer elements
Object[] r = new Object[size()];
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // fewer elements than expected
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
|
| public T[] | toArray(T[] a){@inheritDoc}
This implementation returns an array containing all the elements
returned by this collection's iterator in the same order, stored in
consecutive elements of the array, starting with index {@code 0}.
If the number of elements returned by the iterator is too large to
fit into the specified array, then the elements are returned in a
newly allocated array with length equal to the number of elements
returned by the iterator, even if the size of this collection
changes during iteration, as might happen if the collection permits
concurrent modification during iteration. The {@code size} method is
called only as an optimization hint; the correct result is returned
even if the iterator returns a different number of elements.
This method is equivalent to:
{@code
List list = new ArrayList(size());
for (E e : this)
list.add(e);
return list.toArray(a);
}
// Estimate size of array; be prepared to see more or fewer elements
int size = size();
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
Iterator<E> it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) { // fewer elements than expected
if (a != r)
return Arrays.copyOf(r, i);
r[i] = null; // null-terminate
return r;
}
r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
|
| public java.lang.String | toString()Returns a string representation of this collection. The string
representation consists of a list of the collection's elements in the
order they are returned by its iterator, enclosed in square brackets
("[]"). Adjacent elements are separated by the characters
", " (comma and space). Elements are converted to strings as
by {@link String#valueOf(Object)}.
Iterator<E> i = iterator();
if (! i.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[");
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (! i.hasNext())
return sb.append(']").toString();
sb.append(", ");
}
|
