java.lang.Object | |
↳ | java.util.AbstractCollection<E> |
Known Direct Subclasses
|
Known Indirect Subclasses
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
|
|||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
java.lang.Object
|
|||||||||||
From interface
java.lang.Iterable
|
|||||||||||
From interface
java.util.Collection
|
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
.