|
|||||||||
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.TreeMultiset<E>
public final class TreeMultiset<E>
Multiset implementation backed by a TreeMap
. The multiset elements
are ordered by their natural sort ordering or by a comparator.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface com.google.common.collect.Multiset |
---|
Multiset.Entry<E> |
Constructor Summary | |
---|---|
TreeMultiset()
Constructs a new, empty multiset, sorted according to the elements' natural order. |
|
TreeMultiset(Comparator<? super E> comparator)
Constructs a new, empty multiset, sorted according to the specified comparator. |
|
TreeMultiset(Iterable<? extends E> elements)
Constructs an empty multiset containing the given initial elements, sorted according to the elements' natural order. |
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 . |
SortedSet<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. |
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, 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 TreeMultiset()
Comparable
interface. Furthermore, all such elements must be
mutually comparable: e1.compareTo(e2)
must not throw a
ClassCastException
for any elements e1
and e2
in
the multiset. If the user attempts to add an element to the multiset that
violates this constraint (for example, the user attempts to add a string
element to a set whose elements are integers), the add(Object)
call will throw a ClassCastException
.
public TreeMultiset(Comparator<? super E> comparator)
comparator.compare(e1,
e2)
must not throw a ClassCastException
for any elements e1
and e2
in the multiset. If the user attempts to add an element
to the multiset that violates this constraint, the add(Object)
call
will throw a ClassCastException
.
comparator
- the comparator that will be used to sort this multiset. A
null value indicates that the elements' natural ordering should
be used.public TreeMultiset(Iterable<? extends E> elements)
Method Detail |
---|
public SortedSet<E> elementSet()
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.
In TreeMultiset
, the return type of this method is narrowed
from Set
to SortedSet
.
elementSet
in interface Multiset<E>
elementSet
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>
element
- the element to count occurrences of
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>
element
- the element whose occurrences should all be removed
protected Set<E> createElementSet()
AbstractMultiset
AbstractMultiset.elementSet
.
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 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.protected void readObjectNoData() throws InvalidObjectException
InvalidObjectException
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |