|
|||||||||
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.EnumMultiset<E>
public final class EnumMultiset<E extends Enum<E>>
Multiset implementation backed by an EnumMap
.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface com.google.common.collect.Multiset |
---|
Multiset.Entry<E> |
Constructor Summary | |
---|---|
EnumMultiset(Class<E> type)
Creates an empty EnumMultiset . |
|
EnumMultiset(Iterable<E> elements)
Creates a new EnumMultiset containing the specified elements. |
Method Summary | |
---|---|
boolean |
add(E element,
int occurrences)
Adds a number of occurrences of an element to this multiset. |
protected Map<E,AtomicInteger> |
backingMap()
|
int |
count(Object element)
Returns the number of occurrences of an element in this multiset (the count of the element). |
protected Set<E> |
createElementSet()
Creates a new instance of this multiset's element set, which will be returned by AbstractMultiset.elementSet . |
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. |
Iterator<E> |
iterator()
|
protected void |
readObjectNoData()
Don't allow default serialization. |
int |
remove(Object element,
int occurrences)
Conditionally removes a number of occurrences of an element from this multiset, provided that at least this many occurrences are present. |
int |
removeAllOccurrences(Object element)
Removes all occurrences of the specified element from this multiset. |
protected void |
setBackingMap(Map<E,AtomicInteger> backingMap)
Used during deserialization only. |
int |
size()
|
Methods inherited from class com.google.common.collect.AbstractMultiset |
---|
add, addAll, clear, contains, containsAll, elementSet, equals, hashCode, isEmpty, remove, removeAll, retainAll, toString |
Methods inherited from class java.util.AbstractCollection |
---|
toArray, toArray |
Methods inherited from class java.lang.Object |
---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
Methods inherited from interface java.util.Collection |
---|
toArray, toArray |
Constructor Detail |
---|
public EnumMultiset(Class<E> type)
EnumMultiset
.
public EnumMultiset(Iterable<E> elements)
EnumMultiset
containing the specified elements.
elements
- the elements that the multiset should contain
IllegalArgumentException
- if elements
is emptyMethod Detail |
---|
protected Map<E,AtomicInteger> backingMap()
protected void setBackingMap(Map<E,AtomicInteger> backingMap)
public Set<Multiset.Entry<E>> entrySet()
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.
Invoking Multiset.Entry.getCount()
on an entry in the returned
set always returns the current count of that element in the multiset, as
opposed to the count at the time the entry was retrieved.
entrySet
in interface Multiset<E>
entrySet
in class AbstractMultiset<E>
public int size()
AbstractMultiset
This implementation iterates across Multiset.entrySet()
and
sums the counts of the entries.
size
in interface Collection<E>
size
in class AbstractMultiset<E>
public Iterator<E> iterator()
AbstractMultiset
This implementation usually invokes methods of the
Multiset.entrySet()
iterator. However, the iterator's
remove
method sometimes calls the multiset's remove
.
iterator
in interface Iterable<E>
iterator
in interface Collection<E>
iterator
in class AbstractMultiset<E>
public int count(@Nullable Object element)
AbstractMultiset
Object.equals(java.lang.Object)
-based
multiset, this gives the same result as Collections.frequency(java.util.Collection>, java.lang.Object)
(which would presumably perform more poorly).
Note: the utility method Iterables.frequency(java.lang.Iterable>, java.lang.Object)
generalizes
this operation; it correctly delegates to this method when dealing with a
multiset, but it can also accept any other iterable type.
This implementation iterates across Multiset.entrySet()
and
sums the count of all entries.
count
in interface Multiset<E>
count
in class AbstractMultiset<E>
element
- the element to count occurrences of
public boolean add(@Nullable E element, int occurrences)
occurrences == 1
, this method has the identical effect to Multiset.add(Object)
. This method is functionally equivalent (except in the case
of overflow) to the call addAll(Collections.nCopies(element,
occurrences))
, which would presumably perform much more poorly.
This implementation always throws an
UnsupportedOperationException
. To support adding elements, override
it.
add
in interface Multiset<E>
add
in class AbstractMultiset<E>
element
- the element to add occurrences of; may be null
only
if explicitly allowed by the implementationoccurrences
- the number of occurrences of this element to add. May
be zero, in which case no change will be made.
IllegalArgumentException
- if the call would result in more than
Integer.MAX_VALUE
occurrences of element
in this
multiset.public int remove(@Nullable Object element, int occurrences)
AbstractMultiset
occurrences
, no change is made.
Note that if
occurrences == 1
, this is functionally equivalent to the call
remove(element)
.
This implementation always throws an
UnsupportedOperationException
. To support removing elements,
override it.
remove
in interface Multiset<E>
remove
in class AbstractMultiset<E>
element
- the element to conditionally remove occurrences ofoccurrences
- the number of occurrences of this element to remove. May
be zero, in which case no change will be made.
true
if the condition for modification was met. Unless
occurrences
is zero, this implies that the multiset was indeed
modified.public int removeAllOccurrences(@Nullable Object element)
AbstractMultiset
Multiset.remove(Object)
, which removes only
one occurrence at a time.
TODO: Nuke this. Use setCount(e, 0).
This implementation calls AbstractMultiset.remove(Object, int)
with
Integer.MAX_VALUE
occurrences.
removeAllOccurrences
in interface Multiset<E>
removeAllOccurrences
in class AbstractMultiset<E>
element
- the element whose occurrences should all be removed
protected Set<E> createElementSet()
AbstractMultiset
AbstractMultiset.elementSet
.
createElementSet
in class AbstractMultiset<E>
protected void readObjectNoData() throws InvalidObjectException
InvalidObjectException
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |