TopBlend:
Here is the
first difference.
There are 153 differences.
is old.
is new.
java.util.concurrent
Class CopyOnWriteArraySet<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E>
java.util.concurrent.CopyOnWriteArraySet<E>
-
-
Type Parameters:
-
E - the type of elements held in this collection
-
All Implemented Interfaces:
-
Serializable
,
Iterable
<E>,
Collection
<E>,
Set
<E>
-
public class CopyOnWriteArraySet<E>
- extends AbstractSet<E>
- implements Serializable
A
Set
that uses
an internal
CopyOnWriteArrayList
for all of its operations. Thus, it shares the same basic properties:
-
It is best suited for applications in which set sizes generally stay small, read-only operations vastly outnumber mutative operations, and you need to prevent interference among threads during traversal.
-
It is thread-safe.
-
Mutative
operations (
add
,
set
,
remove
, etc.)
operations(add, set, remove, etc)
are expensive since they usually entail copying the entire underlying array. -
Iterators do not support the mutative
remove
operation.
-
Traversal via iterators is fast and cannot encounter interference from other threads. Iterators rely on unchanging snapshots of the array at the time the iterators were constructed.
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
.
-
Since:
-
1.5
-
See Also:
-
CopyOnWriteArrayList
,
Serialized Form
Method Summary
|
boolean |
add
(
E
Adds
Ensures that this collection contains
the specified element
to this set if it is not already present.
(optional operation).
|
boolean |
addAll
(
Collection
<? extends
E
Adds all of the elements in the specified collection to this
set if they're not already present.
collection (optional operation).
|
void |
clear
()
Removes all of the elements from this
set.
collection (optional operation).
|
boolean |
contains
(
Object
Returns
true
if this
set
collection
contains the specified element. |
boolean |
containsAll
(
Collection
Returns
true
if this
set
collection
contains all of the elements
of
in
the specified collection. |
boolean |
isEmpty
()
Returns
true
if this
set
collection
contains no elements. |
Iterator
<
E
|
iterator
()
Returns an iterator over the elements contained in this
set in the order in which these elements were added.
collection.
|
boolean |
remove
(
Object
Removes
a single instance of
the specified element from this
set
collection,
if it is
present.
present (optional operation).
|
boolean |
removeAll
(
Collection
Removes from this set all of its elements that are contained in the specified
collection.
collection (optional operation).
|
boolean |
retainAll
(
Collection
Retains only the elements in this
set
collection
that are contained in the specified
collection.
collection (optional operation).
|
int |
size
()
Returns the number of elements in this
set.
collection.
|
Object
|
toArray
()
Returns an array containing all of the elements in this
set.
collection.
|
|
toArray
(T[] a)
Returns an array containing all of the elements in this
set;
collection;
the runtime type of the returned array is that of the specified array. |
CopyOnWriteArraySet
public CopyOnWriteArraySet()
-
Creates an empty set.
CopyOnWriteArraySet
public CopyOnWriteArraySet(Collection<? extends E> c)
-
Creates a set containing all of the elements of the specified
collection.
Collection.
-
Parameters:
-
c - the collection of elements to initially contain
-
Throws:
-
NullPointerException
- if the specified collection is null
c - the collection
size
public int size()
-
Returns the number of elements in this set.
Description copied from class:
AbstractCollection
-
Returns the number of elements in this collection. If the collection contains more than
Integer.MAX_VALUE
elements, returns
Integer.MAX_VALUE
.
-
-
Specified by:
-
size
in interface
Collection
<
E
>
-
Specified by:
-
size
in interface
Set
<
E
>
-
Specified by:
-
size
in class
AbstractCollection
<
E
>
-
-
Returns:
-
the number of elements in this
set
collection.
isEmpty
public boolean isEmpty()
-
Description copied from class:
AbstractCollection
-
Returns
true
if this
set
collection
contains no elements.
This implementation returns
size() == 0
.
-
-
Specified by:
-
isEmpty
in interface
Collection
<
E
>
-
Specified by:
-
isEmpty
in interface
Set
<
E
>
-
Overrides:
-
isEmpty
in class
AbstractCollection
<
E
>
-
-
Returns:
-
true
if this
set
collection
contains no
elements
elements.
contains
public boolean contains(Object o)
-
Description copied from class:
AbstractCollection
-
Returns
true
if this
set
collection
contains the specified element. More formally, returns
true
if and only if this
set
collection
contains
an
at least one
element
e
such that
(o==null ? e==null : o.equals(e))
(o==null ? e==null : o.equals(e))
.
This implementation iterates over the elements in the collection, checking each element in turn for equality with the specified element.
-
-
Specified by:
-
contains
in interface
Collection
<
E
>
-
Specified by:
-
contains
in interface
Set
<
E
>
-
Overrides:
-
contains
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
o - element whose presence in this set is to be tested
o - object to be checked for containment in this collection.
-
Returns:
-
true
if this
set
collection
contains the specified
element
element.
toArray
public Object[] toArray()
-
Description copied from class:
AbstractCollection
-
Returns an array containing all of the elements in this
set.
collection.
If
this set
the 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.
The returned array will be "safe" in that no references to it are maintained by
this set.
the collection.
(In other words, this method must allocate a new array even if
this set
the collection
is backed by an
array).
Array).
The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
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.
-
-
Specified by:
-
toArray
in interface
Collection
<
E
>
-
Specified by:
-
toArray
in interface
Set
<
E
>
-
Overrides:
-
toArray
in class
AbstractCollection
<
E
>
-
-
Returns:
-
an array containing all
of
the elements in this
set
collection.
toArray
public <T> T[] toArray(T[] a)
-
Description copied from class:
AbstractCollection
-
Returns an array containing all of the elements in this
set;
collection;
the runtime type of the returned array is that of the specified array. If the
set
collection
fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this
set.
collection.
If
this set
the collection
fits in the specified array with room to spare (i.e., the array has more elements than
this set),
the
collection), the
element in the array immediately following the end of the
set
collection
is set to
null
.
(This
This
is useful in determining the length of
this set
the collection
only
if the caller knows that
this set
the collection
does not contain any
null
elements.)
If this
set
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
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
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
x
null
is a set known to contain only strings. The following code can be used to dump the set 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()
.
is stored in the first location after the end of the collection.
-
-
Specified by:
-
toArray
in interface
Collection
<
E
>
-
Specified by:
-
toArray
in interface
Set
<
E
>
-
Overrides:
-
toArray
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
a - the array into which the elements of
this set
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. -
Returns:
-
an array containing all the elements in this set
-
Throws:
-
ArrayStoreException
- if the runtime type of the specified array is not a supertype of the runtime type of every element in this set
-
NullPointerException
- if the specified array is null
an array containing the elements of the collection.
clear
public void clear()
-
Description copied from class:
AbstractCollection
-
Removes all of the elements from this
set.
collection (optional operation).
The
set
collection
will be empty after this call
returns.
returns (unless it throws an exception).
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.
-
-
Specified by:
-
clear
in interface
Collection
<
E
>
-
Specified by:
-
clear
in interface
Set
<
E
>
-
Overrides:
-
clear
in class
AbstractCollection
<
E
>
-
remove
iterator
public boolean
public Iterator< E> remove iterator ( Object o) ()
-
Removes the specified element from this set if it is present. More formally, removes an element
e
such that
(o==null ? e==null : o.equals(e))
, if this set contains such an element. Returns
true
if this set contained the element (or equivalently, if this set changed as a result of the call). (This set will not contain the element once the call returns.)
Description copied from class:
AbstractCollection
-
Returns an iterator over the elements contained in this collection.
-
-
Specified by:
-
remove
iterator
in interface
Iterable
<
E
>
-
Specified by:
-
iterator
in interface
Collection
<
E
> -
Specified by:
-
remove
iterator
in interface
Set
<
E
> -
Overrides:
Specified by:
-
remove
iterator
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
o - object to be removed from this set, if present
-
Returns:
-
true
if this set contained the specified element
an iterator over the elements contained in this collection.
add
remove
public boolean add remove ( EObject e) o)
-
Adds the specified element to this set if it is not already present. More formally, adds the specified element
Description copied from class:
AbstractCollection
-
Removes a single instance of the specified element from this collection, if it is present (optional operation). More formally, removes an element
e
to this set if the set contains no element
such that
e2
(o==null ? e==null : o.equals(e))
such that
, if the collection contains one or more such elements. Returns
(e==null ? e2==null : e.equals(e2))
true
. If this set already contains the element, the call leaves the set unchanged and returns
if the collection contained the specified element (or equivalently, if the collection changed as a result of the call).
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
false
UnsupportedOperationException
.
if the iterator returned by this collection's iterator method does not implement the
remove
method and this collection contains the specified object.
-
-
Specified by:
-
add
remove
in interface
Collection
<
E
> -
Specified by:
-
add
remove
in interface
Set
<
E
> -
Overrides:
-
add
remove
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
e
o
- element to be
added to
removed from
this
set
collection, if present.
-
Returns:
-
true
if this set did not already contain the specified element
if the collection contained the specified element.
containsAll
add
public boolean containsAll add ( CollectionE<?> c) o)
-
Description copied from class:
AbstractCollection
-
Ensures that this collection contains the specified element (optional operation).
Returns
true
if this set contains all of the elements of the specified collection. If the specified collection is also a set, this method returns
if the collection changed as a result of the call. (Returns
true
false
if it is a
subset
of this set.
if this collection does not permit duplicates and already contains the specified element.) Collections that support this operation may place limitations on what elements may be added to the 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.
This implementation always throws an
UnsupportedOperationException
.
-
-
Specified by:
-
containsAll
add
in interface
Collection
<
E
> -
Specified by:
-
containsAll
add
in interface
Set
<
E
> -
Overrides:
-
containsAll
add
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
c - collection to be checked for containment in this set
o - element whose presence in this collection is to be ensured.
-
Returns:
-
true
if this set contains all of the elements of the specified collection
-
Throws:
-
NullPointerException
- if the specified collection is null
-
See Also:
-
contains(Object)
if the collection changed as a result of the call.
addAll
containsAll
public boolean addAll containsAll (Collection<? extends E> c) <?> c)
-
Adds all of the elements in the specified collection to this set if they're not already present. If the specified collection is also a set, the
Description copied from class:
AbstractCollection
-
Returns
addAll
true
operation effectively modifies this set so that its value is the
union
of the two sets. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress.
if this collection contains all of the elements in the specified collection.
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
.
-
-
Specified by:
-
addAll
containsAll
in interface
Collection
<
E
> -
Specified by:
-
addAll
containsAll
in interface
Set
<
E
> -
Overrides:
-
addAll
containsAll
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
c - collection
containing elements
to be
added to
checked for containment in
this
set
collection.
-
Returns:
-
true
if this set changed as a result of the call
if this collection contains all of the elements in the specified collection.
-
Throws:
-
NullPointerException
- if the specified collection is null
-
See Also:
-
add(Object)
AbstractCollection.contains(Object)
removeAll
addAll
public boolean removeAll addAll (Collection<?> c) <? extends E> c)
-
Removes from this set all of its elements that are contained in the specified collection. If the specified collection is also a set, this operation effectively modifies this set so that its value is the
asymmetric set difference
of the two sets.
Description copied from class:
AbstractCollection
-
Adds all of the elements in the specified collection to this collection (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this collection, and this collection is nonempty.)
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).
-
-
Specified by:
-
removeAll
addAll
in interface
Collection
<
E
> -
Specified by:
-
removeAll
addAll
in interface
Set
<
E
> -
Overrides:
-
removeAll
addAll
in class
AbstractSet
AbstractCollection
<
E
>
-
-
Parameters:
-
c - collection
containing
whose
elements
are
to be
removed from
added to
this
set
collection.
-
Returns:
-
true
if this
set
collection
changed as a result of the
call
call.
-
Throws:
-
ClassCastException
- if the class of an element of this set is incompatible with the specified collection (optional)
-
NullPointerException
- if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null
-
See Also:
-
remove(Object)
AbstractCollection.add(Object)
retainAll
removeAll
public boolean retainAll removeAll (Collection<?> c)
-
Retains only the elements in this set that are contained in the specified collection. In other words, removes from this set all of its elements that are not contained in the specified collection. If the specified collection is also a set, this operation effectively modifies this set so that its value is the
intersection
of the two sets.
Description copied from class:
AbstractSet
-
Removes from this set all of its elements that are contained in the specified collection (optional operation).
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
iterator
method does not implement the
remove
method.
-
-
Specified by:
-
retainAll
removeAll
in interface
Collection
<
E
> -
Specified by:
-
retainAll
removeAll
in interface
Set
<
E
> -
Overrides:
-
retainAll
removeAll
in class
AbstractCollection
AbstractSet
<
E
>
-
-
Parameters:
-
c -
collection containing
elements to be
retained in
removed from
this
set
set.
-
Returns:
-
true
if this set changed as a result of the
call
call.
-
Throws:
See Also:
-
ClassCastException
AbstractCollection.remove(Object)
- if the class of an element of this set is incompatible with the specified collection (optional)
-
NullPointerException
,
AbstractCollection.contains(Object)
- if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null
-
See Also:
-
remove(Object)
iterator
retainAll
public Iterator< E>
public boolean iterator retainAll () ( Collection<?> c)
-
Returns an iterator over the elements contained in this set in the order in which these elements were added.
Description copied from class:
AbstractCollection
-
Retains only the elements in this collection that are contained in the specified collection (optional operation). In other words, removes from this collection all of its elements that are not contained in the specified collection.
The returned iterator provides a snapshot of the state of the set when the iterator was constructed. No synchronization is needed while traversing the iterator. The iterator does NOT support the
This implementation iterates over this collection, checking each element returned by the iterator in turn to see if it's contained in the specified collection. If it's not so contained, it's removed from this collection with the iterator's
remove
method.
Note that this implementation will throw an
UnsupportedOperationException
if the iterator returned by the
iterator
method does not implement the
remove
method and this collection contains one or more elements not present in the specified collection.
-
-
Specified by:
-
iterator
retainAll
in interface
Iterable
<
E
>
-
Specified by:
-
iterator
in interface
Collection
<
E
>
-
Specified by:
-
iterator
retainAll
in interface
Set
<
E
> -
Specified by:
Overrides:
-
iterator
retainAll
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
c - elements to be retained in this collection.
-
Returns:
-
an iterator over the elements in this set
true
if this collection changed as a result of the call.
-
See Also:
-
AbstractCollection.remove(Object)
,
AbstractCollection.contains(Object)