java.util
Class AbstractCollection
java.lang.Object
|
+--java.util.AbstractCollection
All Implemented Interfaces:
Collection
A basic implementation of most of the methods in the Collection interface to
make it easier to create a collection. To create an unmodifiable Collection,
just subclass AbstractCollection and provide implementations of the
iterator() and size() methods. The Iterator returned by iterator() need only
provide implementations of hasNext() and next() (that is, it may throw an
UnsupportedOperationException if remove() is called). To create a modifiable
Collection, you must in addition provide an implementation of the
add(Object) method and the Iterator returned by iterator() must provide an
implementation of remove(). Other methods should be overridden if the
backing data structure allows for a more efficient implementation. The
precise implementation used by AbstractCollection is documented, so that
subclasses can tell which methods could be implemented more efficiently.
The programmer should provide a no-argument constructor, and one that
accepts another Collection, as recommended by the Collection interface.
Unfortunately, there is no way to enforce this in Java.
Since:Authors:- Original author unknown
- Bryce McKinlay
- Eric Blake <ebb9@email.byu.edu>
See Also:
AbstractCollection
protected AbstractCollection()
The main constructor, for use by subclasses.
add
public boolean add(java.lang.Object o)
Add an object to the collection (optional operation). This implementation
always throws an UnsupportedOperationException - it should be
overridden if the collection is to be modifiable. If the collection
does not accept duplicates, simply return false. Collections may specify
limitations on what may be added.
Parameters:
Returns:
- true if the add operation caused the Collection to change
Throws:
addAll
public boolean addAll(java.util.Collection c)
Add all the elements of a given collection to this collection (optional
operation). This implementation obtains an Iterator over the given
collection and iterates over it, adding each element with the
add(Object) method (thus this method will fail with an
UnsupportedOperationException if the add method does). The behavior is
unspecified if the specified collection is modified during the iteration,
including the special case of trying addAll(this) on a non-empty
collection.
Parameters:
Returns:
- true if the add operation caused the Collection to change
Throws:
See Also:
clear
public void clear()
Remove all elements from the collection (optional operation). This
implementation obtains an iterator over the collection and calls next
and remove on it repeatedly (thus this method will fail with an
UnsupportedOperationException if the Iterator's remove method does)
until there are no more elements to remove.
Many implementations will have a faster way of doing this.
Throws:
See Also:
contains
public boolean contains(java.lang.Object o)
Test whether this collection contains a given object. That is, if the
collection has an element e such that (o == null ? e == null :
o.equals(e)). This implementation obtains an iterator over the collection
and iterates over it, testing each element for equality with the given
object. If it is equal, true is returned. Otherwise false is returned when
the end of the collection is reached.
Parameters:
Returns:
- true if this collection contains an object equal to o
containsAll
public boolean containsAll(java.util.Collection c)
Tests whether this collection contains all the elements in a given
collection. This implementation iterates over the given collection,
testing whether each element is contained in this collection. If any one
is not, false is returned. Otherwise true is returned.
Parameters:
Returns:
- true if this collection contains all the elements in the given
collection
Throws:
See Also:
isEmpty
public boolean isEmpty()
Test whether this collection is empty. This implementation returns
size() == 0.
Returns:
- true if this collection is empty.
See Also:
iterator
public Iterator iterator()
Return an Iterator over this collection. The iterator must provide the
hasNext and next methods and should in addition provide remove if the
collection is modifiable.
Returns:
remove
public boolean remove(java.lang.Object o)
Remove a single instance of an object from this collection (optional
operation). That is, remove one element e such that
(o == null ? e == null : o.equals(e))
, if such an element
exists. This implementation obtains an iterator over the collection
and iterates over it, testing each element for equality with the given
object. If it is equal, it is removed by the iterator's remove method
(thus this method will fail with an UnsupportedOperationException if
the Iterator's remove method does). After the first element has been
removed, true is returned; if the end of the collection is reached, false
is returned.
Parameters:
Returns:
- true if the remove operation caused the Collection to change, or
equivalently if the collection did contain o.
Throws:
See Also:
removeAll
public boolean removeAll(java.util.Collection c)
Remove from this collection all its elements that are contained in a given
collection (optional operation). This implementation iterates over this
collection, and for each element tests if it is contained in the given
collection. If so, it is removed by the Iterator's remove method (thus
this method will fail with an UnsupportedOperationException if the
Iterator's remove method does).
Parameters:
Returns:
- true if the remove operation caused the Collection to change
Throws:
See Also:
retainAll
public boolean retainAll(java.util.Collection c)
Remove from this collection all its elements that are not contained in a
given collection (optional operation). This implementation iterates over
this collection, and for each element tests if it is contained in the
given collection. If not, it is removed by the Iterator's remove method
(thus this method will fail with an UnsupportedOperationException if
the Iterator's remove method does).
Parameters:
Returns:
- true if the remove operation caused the Collection to change
Throws:
See Also:
size
public int size()
Return the number of elements in this collection. If there are more than
Integer.MAX_VALUE elements, return Integer.MAX_VALUE.
Returns:
toArray
public Object[] toArray()
Return an array containing the elements of this collection. This
implementation creates an Object array of size size() and then iterates
over the collection, setting each element of the array from the value
returned by the iterator. The returned array is safe, and is not backed
by the collection.
Returns:
- an array containing the elements of this collection
toArray
public Object[] toArray(java.lang.Object[] a)
Copy the collection into a given array if it will fit, or into a
dynamically created array of the same run-time type as the given array if
not. If there is space remaining in the array, the first element after the
end of the collection is set to null (this is only useful if the
collection is known to contain no null elements, however). This
implementation first tests whether the given array is large enough to hold
all the elements of the collection. If not, the reflection API is used to
allocate a new array of the same run-time type. Next an iterator is
obtained over the collection and the elements are placed in the array as
they are returned by the iterator. Finally the first spare element, if
any, of the array is set to null, and the created array is returned.
The returned array is safe; it is not backed by the collection. Note that
null may not mark the last element, if the collection allows null
elements.
Parameters:
Returns:
- the array that was produced
Throws:
toString
public String toString()
Creates a String representation of the Collection. The string returned is
of the form "[a, b, ...]" where a and b etc are the results of calling
toString on the elements of the collection. This implementation obtains an
Iterator over the Collection and adds each element to a StringBuffer as it
is returned by the iterator.
Returns:
- a String representation of the Collection
The programmer should provide a no-argument constructor, and one that accepts another Collection, as recommended by the Collection interface. Unfortunately, there is no way to enforce this in Java.