|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.util.AbstractCollection<E>
com.google.common.collect.AbstractMultiset<E>
com.google.common.collect.ConcurrentMultiset<E>
public final class ConcurrentMultiset<E>
A multiset that supports concurrent modifications and that provides atomic
versions of most Multiset
operations (exceptions where noted).
This implementation is backed by a ConcurrentMap
, and several of
its properties will depend on the behavior of this backing map: for example,
it can contain only values that are legal keys for the backing map. Thus,
when using the default ConcurrentHashMap
, this implementation cannot
contain null
.
An instance of this class is serializable, as long as all of its elements
are serializable and the instance wasn't created by passing a
non-serializable map to ConcurrentMultiset(ConcurrentMap)
.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface com.google.common.collect.Multiset |
---|
Multiset.Entry<E> |
Constructor Summary | |
---|---|
ConcurrentMultiset()
Creates an empty instance using a ConcurrentHashMap to store
elements and their counts. |
|
ConcurrentMultiset(Collection<? extends E> collection)
Creates an instance using a ConcurrentHashMap to store elements
and their counts, and initially containing all the elements from a given
collection. |
|
ConcurrentMultiset(ConcurrentMap<E,Integer> countMap)
Creates an instance using countMap to store elements and their
counts. |
Method Summary | ||
---|---|---|
boolean |
add(E element,
int occurrences)
Adds a number of occurrences of the specified element to this multiset. |
|
int |
count(Object element)
Returns the number of occurrences of element in this multiset. |
|
Set<E> |
elementSet()
Returns the set of distinct elements contained in this multiset. |
|
Set<Multiset.Entry<E>> |
entrySet()
Returns a view of the contents of this multiset, grouped into Multiset.Entry instances, each providing an element of the multiset and
the count of that element. |
|
int |
remove(Object element,
int occurrences)
Removes a number of occurrences of the specified element from this multiset. |
|
int |
removeAllOccurrences(Object element)
Removes all occurrences of the specified element from this multiset. |
|
boolean |
removeExactly(Object element,
int occurrences)
Removes exactly the specified number of occurrences of element , or
makes no change if this is not possible. |
|
int |
setCount(E element,
int count)
Adds or removes occurrences of element such that the count(java.lang.Object)
of the element becomes count . |
|
boolean |
setCount(E element,
int oldCount,
int newCount)
Sets the number of occurrences of element to newCount , but
only if the count is currently oldCount . |
|
int |
size()
|
|
Object[] |
toArray()
|
|
|
toArray(T[] array)
|
Methods inherited from class com.google.common.collect.AbstractMultiset |
---|
add, addAll, clear, contains, containsAll, createElementSet, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, toString |
Methods inherited from class java.lang.Object |
---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public ConcurrentMultiset()
ConcurrentHashMap
to store
elements and their counts.
The ConcurrentHashMap
will have default capacity, load factor,
and concurrency settings. For more control, use
ConcurrentMultiset(ConcurrentMap)
.
public ConcurrentMultiset(Collection<? extends E> collection)
ConcurrentHashMap
to store elements
and their counts, and initially containing all the elements from a given
collection.
The ConcurrentHashMap
will have default capacity, load factor,
and concurrency settings. For more control, use
ConcurrentMultiset(ConcurrentMap)
.
public ConcurrentMultiset(ConcurrentMap<E,Integer> countMap)
countMap
to store elements and their
counts.
This instance will assume ownership of countMap
, and other code
should not maintain references to the map or modify it in any way.
countMap
- backing map for storing the elements in the multiset and
their counts. Must be empty.
IllegalArgumentException
- if countMap
is not emptyMethod Detail |
---|
public int count(@Nullable Object element)
element
in this multiset.
count
in interface Multiset<E>
count
in class AbstractMultiset<E>
element
- the element to look for
public Object[] toArray()
toArray
in interface Collection<E>
toArray
in class AbstractCollection<E>
public <T> T[] toArray(T[] array)
toArray
in interface Collection<E>
toArray
in class AbstractCollection<E>
public boolean add(E element, int occurrences)
To succeed, element
must be a legal key in the backing map. In
the case of the default ConcurrentHashMap
, this means it must not
be null
, but other Map
implementations may allow null
.
add
in interface Multiset<E>
add
in class AbstractMultiset<E>
element
- the element to addoccurrences
- the number of occurrences to add
true
if the collection changed as a result (this should
always be the case unless occurrences
is zero)
IllegalArgumentException
- if occurrences
is negative, or if
the resulting amount would exceed Integer.MAX_VALUE
public int remove(@Nullable Object element, int occurrences)
remove
in interface Multiset<E>
remove
in class AbstractMultiset<E>
element
- the element whose occurrences should be removedoccurrences
- the number of occurrences of this element to remove
IllegalArgumentException
- if occurrences
is negativepublic int removeAllOccurrences(@Nullable Object element)
Multiset.remove(Object)
, which removes only
one occurrence at a time.
removeAllOccurrences
in interface Multiset<E>
removeAllOccurrences
in class AbstractMultiset<E>
element
- the element whose occurrences should all be removed
public int size()
This implementation iterates across Multiset.entrySet()
and
sums the counts of the entries.
If the data in the multiset is modified by any other threads during this method, it is undefined which (if any) of these modifications will be reflected in the result.
size
in interface Collection<E>
size
in class AbstractMultiset<E>
public int setCount(E element, int count)
element
such that the count(java.lang.Object)
of the element becomes count
.
element
in the multiset before this call
IllegalArgumentException
- if count
is negativepublic boolean setCount(E element, int oldCount, int newCount)
element
to newCount
, but
only if the count is currently oldCount
. If element
does
not appear in the multiset exactly oldCount
times, no changes will
be made.
true
if the change was successful. This usually indicates
that the multiset has been modified, but not always: in the case
that oldCount == newCount
, the method will return
true
if the condition was met.
IllegalArgumentException
- if oldCount
or newCount
is
negativepublic boolean removeExactly(@Nullable Object element, int occurrences)
element
, or
makes no change if this is not possible.
This method, in contrast to remove(Object, int)
, has no effect
when the element count is smaller than occurrences
.
element
- the element to removeoccurrences
- the number of occurrences of element
to remove
true
if the removal was possible (including if occurrences
is zero)public Set<E> elementSet()
AbstractMultiset
If the element set supports any removal operations, these necessarily cause all occurrences of the removed element(s) to be removed from the multiset. Implementations are not expected to support the add operations, although this is possible.
A common use for the element set is to find the number of distinct
elements in the multiset: elementSet().size()
.
The returned set's methods are implemented by calling
Multiset.entrySet()
methods.
elementSet
in interface Multiset<E>
elementSet
in class AbstractMultiset<E>
public Set<Multiset.Entry<E>> entrySet()
Multiset
Multiset.Entry
instances, each providing an element of the multiset and
the count of that element. This set contains exactly one entry for each
distinct element in the multiset (thus it always has the same size as the
Multiset.elementSet()
). The order of the elements in the element set is
unspecified.
The entry set is backed by the same data as the multiset, so any change
to either is immediately reflected in the other. However, multiset changes
may or may not be reflected in any Entry
instances already
retrieved from the entry set (this is implementation-dependent).
Furthermore, implementations are not required to support modifications to
the entry set at all, and the Entry
instances themselves don't
even have methods for modification. See the specific implementation class
for more details on how its entry set handles modifications.
entrySet
in interface Multiset<E>
entrySet
in class AbstractMultiset<E>
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |