| Overview | Package | Class | Tree | Deprecated | Index | Help | Codase Click  search sample or example code,  search definition,  search google |
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectjava.util.AbstractCollection
E - the type of elements held in this collection , Iterable <E>, Collection <E>, Set <E>public class CopyOnWriteArraySet<E>
<E>
A Set that uses CopyOnWriteArrayList for all of its
operations. Thus, it shares the same basic properties:
Sample Usage. The following code sketch uses a copy-on-write set to maintain a set of Handler objects that perform some action upon state updates.
class Handler { void handle(); ... }
class X {
private final CopyOnWriteArraySet<Handler> handlers = new CopyOnWriteArraySet<Handler>();
public void addHandler(Handler h) { handlers.add(h); }
private long internalState;
private synchronized void changeState() { internalState = ...; }
public void update() {
changeState();
for (Handler handler : handlers)
handler.handle();
}
}
This class is a member of the Java Collections Framework.
CopyOnWriteArrayList ,
Serialized Form| Constructor Summary | |
|---|---|
CopyOnWriteArraySet
Creates an empty set. |
|
CopyOnWriteArraySet
Creates a set containing all of the elements of the specified Collection. |
|
| Method Summary | ||
|---|---|---|
boolean |
add
Ensures that this collection contains the specified element (optional operation). |
|
boolean |
addAll
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
Returns true if this collection contains the specified element. |
|
boolean |
containsAll
Returns true if this collection contains all of the elements in the specified collection. |
|
boolean |
isEmpty
Returns true if this collection contains no elements. |
|
Iterator |
iterator
Returns an iterator over the elements contained in this collection. |
|
boolean |
remove
Removes a single instance of the specified element from this collection, if it is present (optional operation). |
|
boolean |
removeAll
Removes from this set all of its elements that are contained in the specified collection (optional operation). |
|
boolean |
retainAll
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. |
|
Object |
toArray
Returns an array containing all of the elements in this collection. |
|
|
toArray
Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. |
|
| Methods inherited from class java.util.AbstractSet |
|---|
equals |
| Methods inherited from class java.util.AbstractCollection |
|---|
toString |
| Methods inherited from class java.lang.Object |
|---|
clone |
| Constructor Detail |
|---|
public CopyOnWriteArraySet()
public CopyOnWriteArraySet(Collection
c - the collection| Method Detail |
|---|
public int size()
AbstractCollection
size in interface Collection <E>size in interface Set <E>size in class AbstractCollection <E> public boolean isEmpty()
AbstractCollection This implementation returns size() == 0.
isEmpty in interface Collection <E>isEmpty in interface Set <E>isEmpty in class AbstractCollection <E> public boolean contains(Object
AbstractCollection 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>contains in interface Set <E>contains in class AbstractCollection <E>o - object to be checked for containment in this collection.
public Object
AbstractCollection This implementation allocates the array to be returned, and iterates over the elements in the collection, storing each object reference in the next consecutive element of the array, starting with element 0.
toArray in interface Collection <E>toArray in interface Set <E>toArray in class AbstractCollection <E> public <T> T[] toArray(T[] a)
AbstractCollection If the collection fits in the specified array with room to spare (i.e., the array has more elements than the 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 the collection only if the caller knows that the 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.
This implementation checks if the array is large enough to contain the collection; if not, it allocates a new array of the correct size and type (using reflection). Then, it iterates over the collection, storing each object reference in the next consecutive element of the array, starting with element 0. If the array is larger than the collection, a null is stored in the first location after the end of the collection.
toArray in interface Collection <E>toArray in interface Set <E>toArray in class AbstractCollection <E>a - the array into which the elements of the collection are to
be stored, if it is big enough; otherwise, a new array of the
same runtime type is allocated for this purpose.
public void clear()
AbstractCollection 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>clear in interface Set <E>clear in class AbstractCollection <E> public Iterator
AbstractCollection
iterator in interface Iterable <E>iterator in interface Collection <E>iterator in interface Set <E>iterator in class AbstractCollection <E> public boolean remove(Object
AbstractCollection 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>remove in interface Set <E>remove in class AbstractCollection <E>o - element to be removed from this collection, if present.
public boolean add(E o)
AbstractCollection This implementation always throws an UnsupportedOperationException.
add in interface Collection <E>add in interface Set <E>add in class AbstractCollection <E>o - element whose presence in this collection is to be ensured.
public boolean containsAll(Collection
AbstractCollection This implementation iterates over the specified collection, checking each element returned by the iterator in turn to see if it's contained in this collection. If all elements are so contained true is returned, otherwise false.
containsAll in interface Collection <E>containsAll in interface Set <E>containsAll in class AbstractCollection <E>c - collection to be checked for containment in this collection.
AbstractCollection.contains(Object) public boolean addAll(Collection
AbstractCollection This implementation iterates over the specified collection, and adds each object returned by the iterator to this collection, in turn.
Note that this implementation will throw an UnsupportedOperationException unless add is overridden (assuming the specified collection is non-empty).
addAll in interface Collection <E>addAll in interface Set <E>addAll in class AbstractCollection <E>c - collection whose elements are to be added to this collection.
AbstractCollection.add(Object) public boolean removeAll(Collection
AbstractSet This implementation determines which is the smaller of this set and the specified collection, by invoking the size method on each. If this set has fewer elements, then the implementation iterates over this set, checking each element returned by the iterator in turn to see if it is contained in the specified collection. If it is so contained, it is removed from this set with the iterator's remove method. If the specified collection has fewer elements, then the implementation iterates over the specified collection, removing from this set each element returned by the iterator, using this set's remove method.
Note that this implementation will throw an UnsupportedOperationException if the iterator returned by the iterato