java.lang.Object | |
↳ | java.util.AbstractCollection<E> |
![]() |
![]()
AbstractSequentialList<E>,
ArrayBlockingQueue<E>,
ArrayList<E>,
ConcurrentLinkedQueue<E>,
ConcurrentSkipListSet<E>,
CopyOnWriteArraySet<E>,
DelayQueue<E extends
Delayed>,
EnumSet<E extends
Enum<E>>,
HashSet<E>,
LinkedBlockingDeque<E>,
LinkedBlockingQueue<E>,
LinkedHashSet<E>,
LinkedList<E>,
PriorityBlockingQueue<E>,
PriorityQueue<E>,
Stack<E>,
SynchronousQueue<E>,
TreeSet<E>,
Vector<E>
|
Class AbstractCollection
is an abstract implementation of the Collection
interface. A subclass must implement the abstract methods iterator()
and size()
to create an immutable collection. To create a modifiable collection it's necessary to override the add()
method that currently throws an UnsupportedOperationException
.
Protected Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
|
Constructs a new instance of this AbstractCollection.
|
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 .
|
||||||||||
|
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 .
|
||||||||||
|
Returns the string representation of this
Collection .
|
[Expand]
Inherited Methods
|
|||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
![]() |
|||||||||||
![]() |
|||||||||||
![]() |
Constructs a new instance of this AbstractCollection.
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. |
---|
true
if this Collection
is modified, false
otherwise.Attempts to add all of the objects contained in collection
to the contents of this Collection
(optional). This implementation iterates over the given Collection
and calls add
for each element. If any of these calls return true
, then true
is returned as result of this method call, false
otherwise. If this Collection
does not support adding elements, an UnsupportedOperationException
is thrown.
If the passed Collection
is changed during the process of adding elements to this Collection
, the behavior depends on the behavior of the passed Collection
.
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). This implementation iterates over this Collection
and calls the remove
method on each element. If the iterator does not support removal of elements, an UnsupportedOperationException
is thrown.
Concrete implementations usually can clear a Collection
more efficiently and should therefore overwrite this method.
UnsupportedOperationException | it the iterator does not support removing elements from this Collection |
---|
Tests whether this Collection
contains the specified object. This implementation iterates over this Collection
and tests, whether any element is equal to the given object. If object != null
then object.equals(e)
is called for each element e
returned by the iterator until the element is found. If object == null
then each element e
returned by the iterator is compared with the test e == null
.
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
. This implementation iterates over the specified Collection
. If one element returned by the iterator is not contained in this Collection
, then false
is returned; true
otherwise.
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 . |
Returns if this Collection
contains no elements. This implementation tests, whether size
returns 0.
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 unless the instance of the Collection
has a defined order. In that case, the elements are returned in that order.
In this class this method is declared abstract and has to be implemented by concrete Collection
implementations.
Collection
contents. Removes one instance of the specified object from this Collection
if one is contained (optional). This implementation iterates over this Collection
and tests for each element e
returned by the iterator, whether e
is equal to the given object. If object != null
then this test is performed using object.equals(e)
, otherwise using object == null
. If an element equal to the given object is found, then the remove
method is called on the iterator and true
is returned, false
otherwise. If the iterator does not support removing elements, an UnsupportedOperationException
is thrown.
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.
This implementation iterates over this Collection
and tests for each element e
returned by the iterator, whether it is contained in the specified Collection
. If this test is positive, then the remove
method is called on the iterator. If the iterator does not support removing elements, an UnsupportedOperationException
is thrown.
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.
This implementation iterates over this Collection
and tests for each element e
returned by the iterator, whether it is contained in the specified Collection
. If this test is negative, then the remove
method is called on the iterator. If the iterator does not support removing elements, an UnsupportedOperationException
is thrown.
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.
In this class this method is declared abstract and has to be implemented by concrete Collection
implementations.
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.
contents | the array. |
---|
Collection
.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
. Returns the string representation of this Collection
. The presentation has a specific format. It is enclosed by square brackets ("[]"). Elements are separated by ', ' (comma and space).
Collection
.