|
|||||||||
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). Null
elements are not supported.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface com.google.common.collect.Multiset |
---|
Multiset.Entry<E> |
Constructor Summary | |
---|---|
ConcurrentMultiset()
Creates an empty instance. |
|
ConcurrentMultiset(Collection<? extends E> collection)
Creates an instance that contains the elements in a given collection. |
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()
public ConcurrentMultiset(Collection<? extends E> collection)
Method 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 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 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)
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 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 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 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 |