Class ConcurrentHashMultiset<E>

java.lang.Object
java.util.AbstractCollection<E>
com.google.common.collect.AbstractMultiset<E>
com.google.common.collect.ConcurrentHashMultiset<E>
All Implemented Interfaces:
Multiset<E>, Serializable, Iterable<E>, Collection<E>

public final class ConcurrentHashMultiset<E> extends AbstractMultiset<E> implements 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:
  • Field Details

  • Constructor Details

  • Method Details

    • 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(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

      public static <E> ConcurrentHashMultiset<E> create(ConcurrentMap<E,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:
      IllegalArgumentException - if countMap is not empty
      Since:
      20.0
    • count

      public int count(@CheckForNull Object element)
      Returns the number of occurrences of element in this multiset.
      Specified by:
      count in interface Multiset<E>
      Parameters:
      element - the element to look for
      Returns:
      the nonnegative number of occurrences of the element
    • size

      public int size()
      Returns the total number of all occurrences of all elements in this multiset.

      Note: this method does not return the number of distinct elements in the multiset, which is given by entrySet().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 Collection<E>
      Specified by:
      size in interface Multiset<E>
      Specified by:
      size in class AbstractCollection<E>
    • toArray

      public Object[] toArray()
      Specified by:
      toArray in interface Collection<E>
      Overrides:
      toArray in class AbstractCollection<E>
    • toArray

      public <T> T[] toArray(T[] array)
      Specified by:
      toArray in interface Collection<E>
      Overrides:
      toArray in class AbstractCollection<E>
    • snapshot

      private 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:
      IllegalArgumentException - if occurrences is negative, or if the resulting amount would exceed Integer.MAX_VALUE
    • remove

      public int remove(@CheckForNull 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:
      IllegalArgumentException - if occurrences is negative
    • removeExactly

      public boolean removeExactly(@CheckForNull 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:
      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:
      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:
      IllegalArgumentException - if expectedOldCount or newCount is negative
    • createElementSet

      Set<E> createElementSet()
      Description copied from class: AbstractMultiset
      Creates a new instance of this multiset's element set, which will be returned by AbstractMultiset.elementSet().
      Overrides:
      createElementSet in class AbstractMultiset<E>
    • elementIterator

      Iterator<E> elementIterator()
      Specified by:
      elementIterator in class AbstractMultiset<E>
    • createEntrySet

      @Deprecated public Set<Multiset.Entry<E>> createEntrySet()
      Deprecated.
      Internal method, use AbstractMultiset.entrySet().
      Overrides:
      createEntrySet in class AbstractMultiset<E>
    • distinctElements

      int distinctElements()
      Specified by:
      distinctElements in class AbstractMultiset<E>
    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface Collection<E>
      Overrides:
      isEmpty in class AbstractMultiset<E>
    • entryIterator

      Iterator<Multiset.Entry<E>> entryIterator()
      Specified by:
      entryIterator in class AbstractMultiset<E>
    • iterator

      public Iterator<E> iterator()
      Description copied from interface: Multiset

      Elements that occur multiple times in the multiset will appear multiple times in this iterator, though not necessarily sequentially.

      Specified by:
      iterator in interface Collection<E>
      Specified by:
      iterator in interface Iterable<E>
      Specified by:
      iterator in interface Multiset<E>
      Specified by:
      iterator in class AbstractCollection<E>
    • clear

      public void clear()
      Specified by:
      clear in interface Collection<E>
      Specified by:
      clear in class AbstractMultiset<E>
    • writeObject

      private void writeObject(ObjectOutputStream stream) throws IOException
      Throws:
      IOException
    • readObject

      private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
      Throws:
      IOException
      ClassNotFoundException