| java.util.Collection<E> |
 Known Indirect Subclasses
AbstractCollection<E>,
AbstractList<E>,
AbstractQueue<E>,
AbstractSequentialList<E>,
AbstractSet<E>,
ArrayBlockingQueue<E>,
ArrayDeque<E>,
ArrayList<E>,
ArraySet<E>,
BlockingDeque<E>,
BlockingQueue<E>,
ConcurrentLinkedDeque<E>,
ConcurrentLinkedQueue<E>,
ConcurrentSkipListSet<E>,
and
24 others.
|
Collection is the root of the collection hierarchy. It defines operations on
data collections and the behavior that they will have in all implementations
of Collections.
All direct or indirect implementations of Collection should implement at
least two constructors. One with no parameters which creates an empty
collection and one with a parameter of type Collection. This second
constructor can be used to create a collection of different type as the
initial collection but with the same elements. Implementations of Collection
cannot be forced to implement these two constructors but at least all
implementations under java.util do.
Methods that change the content of a collection throw an
UnsupportedOperationException if the underlying collection does not
support that operation, though it's not mandatory to throw such an Exception
in cases where the requested operation would not change the collection. In
these cases it's up to the implementation whether it throws an
UnsupportedOperationException or not.
Methods marked with (optional) can throw an
UnsupportedOperationException if the underlying collection doesn't
support that method.
| Public Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
Attempts to add
object to the contents of this
Collection (optional).
| |||||||||||
Attempts to add all of the objects contained in
Collection
to the contents of this Collection (optional).
| |||||||||||
Removes all elements from this
Collection, leaving it empty (optional).
| |||||||||||
Tests whether this
Collection contains the specified object.
| |||||||||||
Tests whether this
Collection contains all objects contained in the
specified Collection.
| |||||||||||
Compares the argument to the receiver, and returns true if they represent
the same object using a class specific comparison.
| |||||||||||
Returns an integer hash code for the receiver.
| |||||||||||
Returns if this
Collection contains no elements.
| |||||||||||
Returns an instance of
Iterator that may be used to access the
objects contained by this Collection.
| |||||||||||
Removes one instance of the specified object from this
Collection if one
is contained (optional).
| |||||||||||
Removes all occurrences in this
Collection of each object in the
specified Collection (optional).
| |||||||||||
Removes all objects from this
Collection that are not also found in the
Collection passed (optional).
| |||||||||||
Returns a count of how many objects this
Collection contains.
| |||||||||||
Returns an array containing all elements contained in this
Collection.
| |||||||||||
Returns a new array containing all elements contained in this
Collection.
| |||||||||||
|
[Expand]
Inherited Methods | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
From interface
java.lang.Iterable
| |||||||||||
Attempts to add object to the contents of this
Collection (optional).
After this method finishes successfully it is guaranteed that the object
is contained in the collection.
If the collection was modified it returns true, false if
no changes were made.
An implementation of Collection may narrow the set of accepted
objects, but it has to specify this in the documentation. If the object
to be added does not meet this restriction, then an
IllegalArgumentException is thrown.
If a collection does not yet contain an object that is to be added and
adding the object fails, this method must throw an appropriate
unchecked Exception. Returning false is not permitted in this case
because it would violate the postcondition that the element will be part
of the collection after this method finishes.
| object | the object to add. |
|---|
Developers
true if this Collection is
modified, false otherwise.| UnsupportedOperationException | if adding to this Collection is not supported. |
|---|---|
| ClassCastException | if the class of the object is inappropriate for this collection. |
| IllegalArgumentException | if the object cannot be added to this Collection. |
| NullPointerException | if null elements cannot be added to the Collection.
|
Attempts to add all of the objects contained in Collection
to the contents of this Collection (optional). If the passed Collection
is changed during the process of adding elements to this Collection, the
behavior is not defined.
| collection | the Collection of objects. |
|---|
true if this Collection is modified, false
otherwise.| UnsupportedOperationException | if adding to this Collection is not supported. |
|---|---|
| ClassCastException | if the class of an object is inappropriate for this
Collection. |
| IllegalArgumentException | if an object cannot be added to this Collection. |
| NullPointerException | if collection is null, or if it
contains null elements and this Collection does
not support such elements.
|
Removes all elements from this Collection, leaving it empty (optional).
| UnsupportedOperationException | if removing from this Collection is not supported. |
|---|
Tests whether this Collection contains the specified object. Returns
true if and only if at least one element elem in this
Collection meets following requirement:
(object==null ? elem==null : object.equals(elem)).
| object | the object to search for. |
|---|
true if object is an element of this Collection,
false otherwise.| ClassCastException | if the object to look for isn't of the correct type. |
|---|---|
| NullPointerException | if the object to look for is null and this
Collection doesn't support null elements.
|
Tests whether this Collection contains all objects contained in the
specified Collection. If an element elem is contained several
times in the specified Collection, the method returns true even
if elem is contained only once in this Collection.
| collection | the collection of objects. |
|---|
true if all objects in the specified Collection are
elements of this Collection, false otherwise.| ClassCastException | if one or more elements of collection isn't of the
correct type. |
|---|---|
| NullPointerException | if collection contains at least one null
element and this Collection doesn't support null
elements. |
| NullPointerException | if collection is null.
|
Compares the argument to the receiver, and returns true if they represent the same object using a class specific comparison.
| object | the object to compare with this object. |
|---|
true if the object is the same as this object and
false if it is different from this object.Returns an integer hash code for the receiver. Objects which are equal return the same value for this method.
Returns if this Collection contains no elements.
true if this Collection has no elements, false
otherwise.Returns an instance of Iterator that may be used to access the
objects contained by this Collection. The order in which the elements are
returned by the iterator is not defined. Only if the instance of the
Collection has a defined order the elements are returned in that order.
Collection contents.
Removes one instance of the specified object from this Collection if one
is contained (optional). The element elem that is removed
complies with (object==null ? elem==null : object.equals(elem).
| object | the object to remove. |
|---|
true if this Collection is modified, false
otherwise.| UnsupportedOperationException | if removing from this Collection is not supported. |
|---|---|
| ClassCastException | if the object passed is not of the correct type. |
| NullPointerException | if object is null and this Collection
doesn't support null elements.
|
Removes all occurrences in this Collection of each object in the
specified Collection (optional). After this method returns none of the
elements in the passed Collection can be found in this Collection
anymore.
| collection | the collection of objects to remove. |
|---|
true if this Collection is modified, false
otherwise.| UnsupportedOperationException | if removing from this Collection is not supported. |
|---|---|
| ClassCastException | if one or more elements of collection
isn't of the correct type. |
| NullPointerException | if collection contains at least one
null element and this Collection doesn't support
null elements. |
| NullPointerException | if collection is null.
|
Removes all objects from this Collection that are not also found in the
Collection passed (optional). After this method returns this Collection
will only contain elements that also can be found in the Collection
passed to this method.
| collection | the collection of objects to retain. |
|---|
true if this Collection is modified, false
otherwise.| UnsupportedOperationException | if removing from this Collection is not supported. |
|---|---|
| ClassCastException | if one or more elements of collection
isn't of the correct type. |
| NullPointerException | if collection contains at least one
null element and this Collection doesn't support
null elements. |
| NullPointerException | if collection is null.
|
Returns a count of how many objects this Collection contains.
Collection contains, or Integer.MAX_VALUE
if there are more than Integer.MAX_VALUE elements in this
Collection.
Returns an array containing all elements contained in this Collection. If
the specified array is large enough to hold the elements, the specified
array is used, otherwise an array of the same type is created. If the
specified array is used and is larger than this Collection, the array
element following the Collection elements is set to null.
If the implementation has ordered elements it will return the element
array in the same order as an iterator would return them.
toArray(new Object[0]) behaves exactly the same way as
toArray() does.
| array | the array. |
|---|
Collection.| ArrayStoreException | if the type of an element in this Collection cannot be
stored in the type of the specified array.
|
|---|
Returns a new array containing all elements contained in this Collection.
If the implementation has ordered elements it will return the element
array in the same order as an iterator would return them.
The array returned does not reflect any changes of the Collection. A new
array is created even if the underlying data structure is already an
array.
Collection.