public abstract class AbstractCollection<E> extends Object implements Collection<E>
Modifier and Type | Method and Description |
---|---|
boolean |
add(E e) |
boolean |
addAll(Collection<? extends E> c) |
void |
clear() |
boolean |
contains(Object o) |
boolean |
containsAll(Collection<?> c) |
boolean |
isEmpty() |
abstract Iterator<E> |
iterator()
Returns an iterator over the elements contained in this collection.
|
boolean |
remove(Object o) |
boolean |
removeAll(Collection<?> c) |
boolean |
retainAll(Collection<?> c) |
abstract int |
size() |
Object[] |
toArray() |
<T> T[] |
toArray(T[] a) |
String |
toString()
Returns a string representation of this collection.
|
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
equals, hashCode
public abstract Iterator<E> iterator()
public abstract int size()
size
in interface Collection<E>
public boolean isEmpty()
This implementation returns size() == 0.
isEmpty
in interface Collection<E>
public boolean contains(Object o)
This implementation iterates over the elements in the collection, checking each element in turn for equality with the specified element.
contains
in interface Collection<E>
ClassCastException
NullPointerException
public Object[] toArray()
This implementation returns an array containing all the elements
returned by this collection's iterator, in the same order, stored in
consecutive elements of the array, starting with index 0
.
The length of the returned array is equal to the number of elements
returned by the iterator, even if the size of this collection changes
during iteration, as might happen if the collection permits
concurrent modification during iteration. The size
method is
called only as an optimization hint; the correct result is returned
even if the iterator returns a different number of elements.
This method is equivalent to:
List<E> list = new ArrayList<E>(size());
for (E e : this)
list.add(e);
return list.toArray();
toArray
in interface Collection<E>
public <T> T[] toArray(T[] a)
This implementation returns an array containing all the elements
returned by this collection's iterator in the same order, stored in
consecutive elements of the array, starting with index 0
.
If the number of elements returned by the iterator is too large to
fit into the specified array, then the elements are returned in a
newly allocated array with length equal to the number of elements
returned by the iterator, even if the size of this collection
changes during iteration, as might happen if the collection permits
concurrent modification during iteration. The size
method is
called only as an optimization hint; the correct result is returned
even if the iterator returns a different number of elements.
This method is equivalent to:
List<E> list = new ArrayList<E>(size());
for (E e : this)
list.add(e);
return list.toArray(a);
toArray
in interface Collection<E>
ArrayStoreException
NullPointerException
public boolean add(E e)
This implementation always throws an UnsupportedOperationException.
add
in interface Collection<E>
UnsupportedOperationException
ClassCastException
NullPointerException
IllegalArgumentException
IllegalStateException
public boolean remove(Object o)
This implementation iterates over the collection looking for the specified element. If it finds the element, it removes the element from the collection using the iterator's remove method.
Note that this implementation throws an UnsupportedOperationException if the iterator returned by this collection's iterator method does not implement the remove method and this collection contains the specified object.
remove
in interface Collection<E>
UnsupportedOperationException
ClassCastException
NullPointerException
public boolean containsAll(Collection<?> c)
containsAll
in interface Collection<E>
public boolean addAll(Collection<? extends E> c)
addAll
in interface Collection<E>
public boolean removeAll(Collection<?> c)
removeAll
in interface Collection<E>
public boolean retainAll(Collection<?> c)
retainAll
in interface Collection<E>
public void clear()
This implementation iterates over this collection, removing each element using the Iterator.remove operation. Most implementations will probably choose to override this method for efficiency.
Note that this implementation will throw an UnsupportedOperationException if the iterator returned by this collection's iterator method does not implement the remove method and this collection is non-empty.
clear
in interface Collection<E>
UnsupportedOperationException
public String toString()
String.valueOf(Object)
.Copyright © 2015 Lucee