@GwtCompatible public abstract class ForwardingCollection<E> extends ForwardingObject implements Collection<E>
Warning: The methods of ForwardingCollection
forward indiscriminately to
the methods of the delegate. For example, overriding add(E)
alone will not change
the behavior of addAll(java.util.Collection<? extends E>)
, which can lead to unexpected behavior. In this case, you should
override addAll
as well, either providing your own implementation, or delegating to the
provided standardAddAll
method.
default
method warning: This class does not forward calls to default
methods. Instead, it inherits their default implementations. When those implementations
invoke methods, they invoke methods on the ForwardingCollection
.
The standard
methods are not guaranteed to be thread-safe, even when all of the
methods that they depend on are thread-safe.
Modifier | Constructor and Description |
---|---|
protected |
ForwardingCollection()
Constructor for use by subclasses.
|
Modifier and Type | Method and Description |
---|---|
boolean |
add(E element)
Ensures that this collection contains the specified element (optional
operation).
|
boolean |
addAll(Collection<? extends E> collection)
Adds all of the elements in the specified collection to this collection
(optional operation).
|
void |
clear()
Removes all of the elements from this collection (optional operation).
|
boolean |
contains(Object object)
Returns true if this collection contains the specified element.
|
boolean |
containsAll(Collection<?> collection)
Returns true if this collection contains all of the elements
in the specified collection.
|
protected abstract Collection<E> |
delegate()
Returns the backing delegate instance that methods are forwarded to.
|
boolean |
isEmpty()
Returns true if this collection contains no elements.
|
Iterator<E> |
iterator()
Returns an iterator over the elements in this collection.
|
boolean |
remove(Object object)
Removes a single instance of the specified element from this
collection, if it is present (optional operation).
|
boolean |
removeAll(Collection<?> collection)
Removes all of this collection's elements that are also contained in the
specified collection (optional operation).
|
boolean |
retainAll(Collection<?> collection)
Retains only the elements in this collection that are contained in the
specified collection (optional operation).
|
int |
size()
Returns the number of elements in this collection.
|
protected boolean |
standardAddAll(Collection<? extends E> collection)
A sensible definition of
addAll(java.util.Collection<? extends E>) in terms of add(E) . |
protected void |
standardClear()
|
protected boolean |
standardContains(@Nullable Object object)
A sensible definition of
contains(java.lang.Object) in terms of iterator() . |
protected boolean |
standardContainsAll(Collection<?> collection)
A sensible definition of
containsAll(java.util.Collection<?>) in terms of contains(java.lang.Object) . |
protected boolean |
standardIsEmpty()
A sensible definition of
isEmpty() as !iterator().hasNext . |
protected boolean |
standardRemove(@Nullable Object object)
A sensible definition of
remove(java.lang.Object) in terms of iterator() , using the iterator's
remove method. |
protected boolean |
standardRemoveAll(Collection<?> collection)
A sensible definition of
removeAll(java.util.Collection<?>) in terms of iterator() , using the iterator's
remove method. |
protected boolean |
standardRetainAll(Collection<?> collection)
A sensible definition of
retainAll(java.util.Collection<?>) in terms of iterator() , using the iterator's
remove method. |
protected Object[] |
standardToArray()
A sensible definition of
toArray() in terms of toArray(Object[]) . |
protected <T> T[] |
standardToArray(T[] array)
|
protected String |
standardToString()
A sensible definition of
ForwardingObject.toString() in terms of iterator() . |
Object[] |
toArray()
Returns an array containing all of the elements in this collection.
|
<T> T[] |
toArray(T[] array)
Returns an array containing all of the elements in this collection;
the runtime type of the returned array is that of the specified array.
|
toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
equals, hashCode, parallelStream, removeIf, spliterator, stream
protected ForwardingCollection()
protected abstract Collection<E> delegate()
ForwardingObject
ForwardingSet.delegate()
. Concrete subclasses override this method to supply the
instance being decorated.delegate
in class ForwardingObject
public Iterator<E> iterator()
java.util.Collection
public int size()
java.util.Collection
size
in interface Collection<E>
@CanIgnoreReturnValue public boolean removeAll(Collection<?> collection)
java.util.Collection
removeAll
in interface Collection<E>
collection
- collection containing elements to be removed from this collectionCollection.remove(Object)
,
Collection.contains(Object)
public boolean isEmpty()
java.util.Collection
isEmpty
in interface Collection<E>
public boolean contains(Object object)
java.util.Collection
contains
in interface Collection<E>
object
- element whose presence in this collection is to be tested@CanIgnoreReturnValue public boolean add(E element)
java.util.Collection
Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added. Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after this call returns.
add
in interface Collection<E>
element
- element whose presence in this collection is to be ensured@CanIgnoreReturnValue public boolean remove(Object object)
java.util.Collection
remove
in interface Collection<E>
object
- element to be removed from this collection, if presentpublic boolean containsAll(Collection<?> collection)
java.util.Collection
containsAll
in interface Collection<E>
collection
- collection to be checked for containment in this collectionCollection.contains(Object)
@CanIgnoreReturnValue public boolean addAll(Collection<? extends E> collection)
java.util.Collection
addAll
in interface Collection<E>
collection
- collection containing elements to be added to this collectionCollection.add(Object)
@CanIgnoreReturnValue public boolean retainAll(Collection<?> collection)
java.util.Collection
retainAll
in interface Collection<E>
collection
- collection containing elements to be retained in this collectionCollection.remove(Object)
,
Collection.contains(Object)
public void clear()
java.util.Collection
clear
in interface Collection<E>
public Object[] toArray()
java.util.Collection
The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
toArray
in interface Collection<E>
@CanIgnoreReturnValue public <T> T[] toArray(T[] array)
java.util.Collection
If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.)
If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
Like the Collection.toArray()
method, this method acts as bridge between
array-based and collection-based APIs. Further, this method allows
precise control over the runtime type of the output array, and may,
under certain circumstances, be used to save allocation costs.
Suppose x is a collection known to contain only strings. The following code can be used to dump the collection into a newly allocated array of String:
String[] y = x.toArray(new String[0]);Note that toArray(new Object[0]) is identical in function to toArray().
toArray
in interface Collection<E>
T
- the runtime type of the array to contain the collectionarray
- the array into which the elements of this collection are to be
stored, if it is big enough; otherwise, a new array of the same
runtime type is allocated for this purpose.protected boolean standardContains(@Nullable Object object)
contains(java.lang.Object)
in terms of iterator()
. If you override
iterator()
, you may wish to override contains(java.lang.Object)
to forward to this
implementation.protected boolean standardContainsAll(Collection<?> collection)
containsAll(java.util.Collection<?>)
in terms of contains(java.lang.Object)
. If you override
contains(java.lang.Object)
, you may wish to override containsAll(java.util.Collection<?>)
to forward to this
implementation.protected boolean standardAddAll(Collection<? extends E> collection)
addAll(java.util.Collection<? extends E>)
in terms of add(E)
. If you override add(E)
, you may wish to override addAll(java.util.Collection<? extends E>)
to forward to this implementation.protected boolean standardRemove(@Nullable Object object)
remove(java.lang.Object)
in terms of iterator()
, using the iterator's
remove
method. If you override iterator()
, you may wish to override remove(java.lang.Object)
to forward to this implementation.protected boolean standardRemoveAll(Collection<?> collection)
removeAll(java.util.Collection<?>)
in terms of iterator()
, using the iterator's
remove
method. If you override iterator()
, you may wish to override removeAll(java.util.Collection<?>)
to forward to this implementation.protected boolean standardRetainAll(Collection<?> collection)
retainAll(java.util.Collection<?>)
in terms of iterator()
, using the iterator's
remove
method. If you override iterator()
, you may wish to override retainAll(java.util.Collection<?>)
to forward to this implementation.protected void standardClear()
clear()
in terms of iterator()
, using the iterator's
remove
method. If you override iterator()
, you may wish to override clear()
to forward to this implementation.protected boolean standardIsEmpty()
isEmpty()
as !iterator().hasNext
. If you override
isEmpty()
, you may wish to override isEmpty()
to forward to this implementation.
Alternately, it may be more efficient to implement isEmpty
as size() == 0
.protected String standardToString()
ForwardingObject.toString()
in terms of iterator()
. If you override
iterator()
, you may wish to override ForwardingObject.toString()
to forward to this
implementation.protected Object[] standardToArray()
toArray()
in terms of toArray(Object[])
. If you
override toArray(Object[])
, you may wish to override toArray()
to forward to
this implementation.protected <T> T[] standardToArray(T[] array)
toArray(Object[])
in terms of size()
and iterator()
. If you override either of these methods, you may wish to override toArray()
to forward to this implementation.Copyright © 2010–2019. All rights reserved.