Package com.google.common.collect

Class ConcurrentHashMultiset<E>

  • All Implemented Interfaces:
    Multiset<E>, java.io.Serializable, java.lang.Iterable<E>, java.util.Collection<E>
    @GwtIncompatible
public final class ConcurrentHashMultiset<E>
extends AbstractMultiset<E>
implements java.io.Serializable
    A multiset that supports concurrent modifications and that provides atomic versions of most Multiset operations (exceptions where noted). Null elements are not supported.

    See the Guava User Guide article on Multiset.

    Since:
    2.0
    See Also:
    Serialized Form

    • Field Detail

      • countMap

        private final transient java.util.concurrent.ConcurrentMap<E,​java.util.concurrent.atomic.AtomicInteger> countMap
        The number of occurrences of each element.

    • Constructor Detail

      • ConcurrentHashMultiset

        ConcurrentHashMultiset​(java.util.concurrent.ConcurrentMap<E,​java.util.concurrent.atomic.AtomicInteger> countMap)

    • Method Detail

      • create

        public static <E> ConcurrentHashMultiset<E> create()
        Creates a new, empty ConcurrentHashMultiset using the default initial capacity, load factor, and concurrency settings.

      • create

        public static <E> ConcurrentHashMultiset<E> create​(java.lang.Iterable<? extends E> elements)
        Creates a new ConcurrentHashMultiset containing the specified elements, using the default initial capacity, load factor, and concurrency settings.

        This implementation is highly efficient when elements is itself a Multiset.

        Parameters:
        elements - the elements that the multiset should contain

      • create

        @Beta
@Deprecated
public static <E> ConcurrentHashMultiset<E> create​(MapMaker mapMaker)
        Deprecated.
        Use create(ConcurrentMap) instead. This method is scheduled for deletion in Guava 21.0.
        Creates a new, empty ConcurrentHashMultiset using mapMaker to construct the internal backing map.

        If this MapMaker is configured to use entry eviction of any kind, this eviction applies to all occurrences of a given element as a single unit. However, most updates to the multiset do not count as map updates at all, since we're usually just mutating the value stored in the map, so MapMaker#expireAfterAccess makes sense (evict the entry that was queried or updated longest ago), but MapMaker#expireAfterWrite doesn't, because the eviction time is measured from when we saw the first occurrence of the object.

        The returned multiset is serializable but any serialization caveats given in MapMaker apply.

        Finally, soft/weak values can be used but are not very useful: the values are created internally and not exposed externally, so no one else will have a strong reference to the values. Weak keys on the other hand can be useful in some scenarios.

        Since:
        15.0 (source compatible (accepting the since removed GenericMapMaker class) since 7.0)

      • create

        @Beta
public static <E> ConcurrentHashMultiset<E> create​(java.util.concurrent.ConcurrentMap<E,​java.util.concurrent.atomic.AtomicInteger> countMap)
        Creates a new, empty ConcurrentHashMultiset using countMap as the internal backing map.

        This instance will assume ownership of countMap, and other code should not maintain references to the map or modify it in any way.

        The returned multiset is serializable if the input map is.

        Parameters:
        countMap - backing map for storing the elements in the multiset and their counts. It must be empty.
        Throws:
        java.lang.IllegalArgumentException - if countMap is not empty
        Since:
        20.0

      • count

        public int count​(@Nullable
                 java.lang.Object element)
        Returns the number of occurrences of element in this multiset.
        Specified by:
        count in interface Multiset<E>
        Overrides:
        count in class AbstractMultiset<E>
        Parameters:
        element - the element to look for
        Returns:
        the nonnegative number of occurrences of the element

      • size

        public int size()

        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.

        Specified by:
        size in interface java.util.Collection<E>
        Overrides:
        size in class AbstractMultiset<E>

      • toArray

        public java.lang.Object[] toArray()
        Specified by:
        toArray in interface java.util.Collection<E>
        Overrides:
        toArray in class java.util.AbstractCollection<E>

      • toArray

        public <T> T[] toArray​(T[] array)
        Specified by:
        toArray in interface java.util.Collection<E>
        Overrides:
        toArray in class java.util.AbstractCollection<E>

      • snapshot

        private java.util.List<E> snapshot()

      • add

        public int add​(E element,
               int occurrences)
        Adds a number of occurrences of the specified element to this multiset.
        Specified by:
        add in interface Multiset<E>
        Overrides:
        add in class AbstractMultiset<E>
        Parameters:
        element - the element to add
        occurrences - the number of occurrences to add
        Returns:
        the previous count of the element before the operation; possibly zero
        Throws:
        java.lang.IllegalArgumentException - if occurrences is negative, or if the resulting amount would exceed Integer.MAX_VALUE

      • remove

        public int remove​(@Nullable
                  java.lang.Object element,
                  int occurrences)
        Removes a number of occurrences of the specified element from this multiset. If the multiset contains fewer than this number of occurrences to begin with, all occurrences will be removed.
        Specified by:
        remove in interface Multiset<E>
        Overrides:
        remove in class AbstractMultiset<E>
        Parameters:
        element - the element whose occurrences should be removed
        occurrences - the number of occurrences of the element to remove
        Returns:
        the count of the element before the operation; possibly zero
        Throws:
        java.lang.IllegalArgumentException - if occurrences is negative

      • removeExactly

        public boolean removeExactly​(@Nullable
                             java.lang.Object element,
                             int occurrences)
        Removes exactly the specified number of occurrences of 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.

        Parameters:
        element - the element to remove
        occurrences - the number of occurrences of element to remove
        Returns:
        true if the removal was possible (including if occurrences is zero)
        Throws:
        java.lang.IllegalArgumentException - if occurrences is negative

      • setCount

        public int setCount​(E element,
                    int count)
        Adds or removes occurrences of element such that the count(java.lang.Object) of the element becomes count.
        Specified by:
        setCount in interface Multiset<E>
        Overrides:
        setCount in class AbstractMultiset<E>
        Parameters:
        element - the element to add or remove occurrences of; may be null only if explicitly allowed by the implementation
        count - the desired count of the element in this multiset
        Returns:
        the count of element in the multiset before this call
        Throws:
        java.lang.IllegalArgumentException - if count is negative

      • setCount

        public boolean setCount​(E element,
                        int expectedOldCount,
                        int newCount)
        Sets the number of occurrences of element to newCount, but only if the count is currently expectedOldCount. If element does not appear in the multiset exactly expectedOldCount times, no changes will be made.
        Specified by:
        setCount in interface Multiset<E>
        Overrides:
        setCount in class AbstractMultiset<E>
        Parameters:
        element - the element to conditionally set the count of; may be null only if explicitly allowed by the implementation
        expectedOldCount - the expected present count of the element in this multiset
        newCount - the desired count of the element in this multiset
        Returns:
        true if the change was successful. This usually indicates that the multiset has been modified, but not always: in the case that expectedOldCount == newCount, the method will return true if the condition was met.
        Throws:
        java.lang.IllegalArgumentException - if expectedOldCount or newCount is negative

      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface java.util.Collection<E>
        Overrides:
        isEmpty in class AbstractMultiset<E>

      • clear

        public void clear()
        Specified by:
        clear in interface java.util.Collection<E>
        Overrides:
        clear in class AbstractMultiset<E>

      • writeObject

        private void writeObject​(java.io.ObjectOutputStream stream)
                  throws java.io.IOException
        Throws:
        java.io.IOException

      • readObject

        private void readObject​(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
        Throws:
        java.io.IOException
        java.lang.ClassNotFoundException