Multiset (abacus-util 1.9.7 API)

java.lang.Object
- com.landawn.abacus.util.Multiset<T>

Type Parameters:

T -

All Implemented Interfaces:

Iterable<T>
```
public final class Multiset<T>
extends Object
implements Iterable<T>
```
A collection that supports order-independent equality, like Set, but may have duplicate elements.
Elements of a Multiset that are equal to one another are referred to as occurrences of the same single element. The total number of occurrences of an element in a Multiset is called the count of that element (the terms "frequency" and "multiplicity" are equivalent, but not used in this API). Since the count of an element is represented as an int, a Multiset may never contain more than MutableInt#MAX_VALUE occurrences of any one element.

Since:

0.8

Author:

Haiyang Li

Constructor Summary

Constructors
Constructor and Description
`Multiset()` Instantiates a new multiset.
`Multiset(Class<? extends Map> valueMapType)` Instantiates a new multiset.
`Multiset(Collection<? extends T> c)` Instantiates a new multiset.
`Multiset(int initialCapacity)` Instantiates a new multiset.
`Multiset(Supplier<? extends Map<T,?>> mapSupplier)` Instantiates a new multiset.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<E extends Exception> void`	`accept(Try.Consumer<? super Multiset<T>,E> action)`
`<E extends Exception> void`	`acceptIfNotEmpty(Try.Consumer<? super Multiset<T>,E> action)` Accept if not empty.
`boolean`	`add(T e)`
`boolean`	`add(T e, int occurrences)`
`boolean`	`addAll(Collection<? extends T> c)` Adds the all.
`boolean`	`addAll(Collection<? extends T> c, int occurrences)` Adds the all.
`boolean`	`addAll(Map<? extends T,Integer> m)` Adds the all.
`boolean`	`addAll(Multiset<? extends T> multiset)` Adds the all.
`int`	`addAndGet(T e)` Adds the and get.
`int`	`addAndGet(T e, int occurrences)` Adds the and get.
`boolean`	`addIfAbsent(T e)` Adds the if absent.
`boolean`	`addIfAbsent(T e, int occurrences)` Adds the if absent.
`u.Optional<Pair<List<T>,Integer>>`	`allMaxOccurrences()` All max occurrences.
`u.Optional<Pair<List<T>,Integer>>`	`allMinOccurrences()` All min occurrences.
`<R,E extends Exception> R`	`apply(Try.Function<? super Multiset<T>,R,E> func)`
`<R,E extends Exception> u.Optional<R>`	`applyIfNotEmpty(Try.Function<? super Multiset<T>,R,E> func)` Apply if not empty.
`u.OptionalDouble`	`averageOfOccurrences()` Average of occurrences.
`void`	`clear()` Clear.
`<E extends Exception> int`	`compute(T key, Try.BiFunction<? super T,Integer,Integer,E> remappingFunction)` The implementation is equivalent to performing the following steps for this Multiset:
`<E extends Exception> int`	`computeIfAbsent(T e, Try.Function<? super T,Integer,E> mappingFunction)` The implementation is equivalent to performing the following steps for this Multiset:
`<E extends Exception> int`	`computeIfPresent(T e, Try.BiFunction<? super T,Integer,Integer,E> remappingFunction)` The implementation is equivalent to performing the following steps for this Multiset:
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`Multiset<T>`	`copy()`
`Set<T>`	`elements()`
`EntryStream<T,Integer>`	`entryStream()`
`boolean`	`equals(Object obj)`
`<E extends Exception> Multiset<T>`	`filter(Try.BiPredicate<? super T,Integer,E> filter)`
`<E extends Exception> Multiset<T>`	`filter(Try.Predicate<? super T,E> filter)`
`Stream<T>`	`flatStream()`
`List<T>`	`flatten()`
`<E extends Exception> void`	`forEach(Try.Consumer<? super T,E> action)`
`<E extends Exception> void`	`forEach(Try.ObjIntConsumer<? super T,E> action)`
`static <T> Multiset<T>`	`from(Collection<? extends T> coll)`
`static <T> Multiset<T>`	`from(Map<? extends T,Integer> m)`
`int`	`get(Object e)`
`int`	`getAndAdd(T e)` Gets the and add.
`int`	`getAndAdd(T e, int occurrences)` Gets the and add.
`int`	`getAndRemove(Object e)` Gets the and remove.
`int`	`getAndRemove(Object e, int occurrences)` Gets the and remove.
`int`	`getAndSet(T e, int occurrences)` The element will be removed if the specified count is 0.
`int`	`getOrDefault(Object e, int defaultValue)` Gets the or default.
`int`	`hashCode()`
`boolean`	`isEmpty()` Checks if is empty.
`Iterator<T>`	`iterator()`
`u.Optional<Pair<T,Integer>>`	`maxOccurrences()`
`<E extends Exception> int`	`merge(T key, int value, Try.BiFunction<Integer,Integer,Integer,E> remappingFunction)` The implementation is equivalent to performing the following steps for this Multiset:
`u.Optional<Pair<T,Integer>>`	`minOccurrences()`
`int`	`occurrencesOf(Object e)`
`static <T> Multiset<T>`	`of(T... a)`
`boolean`	`remove(Object e)` Remove one occurrence from the specified elements.
`boolean`	`remove(Object e, int occurrences)` Remove the specified occurrences from the specified element.
`boolean`	`removeAll(Collection<?> c)` Removes all of this Multiset's elements that are also contained in the specified collection (optional operation).
`boolean`	`removeAll(Collection<?> c, int occurrences)` Remove the specified occurrences from the specified elements.
`boolean`	`removeAll(Map<?,Integer> m)` Removes the all.
`boolean`	`removeAll(Multiset<?> multiset)` Removes the all.
`int`	`removeAllOccurrences(Object e)` Removes the all occurrences.
`<E extends Exception> boolean`	`removeAllOccurrencesIf(Try.BiPredicate<? super T,? super Integer,E> predicate)` Removes the all occurrences if.
`<E extends Exception> boolean`	`removeAllOccurrencesIf(Try.Predicate<? super T,E> predicate)` Removes the all occurrences if.
`int`	`removeAndGet(Object e)` Removes the and get.
`int`	`removeAndGet(Object e, int occurrences)` Removes the and get.
`<E extends Exception> boolean`	`removeIf(int occurrences, Try.BiPredicate<? super T,? super Integer,E> predicate)` Removes the if.
`<E extends Exception> boolean`	`removeIf(int occurrences, Try.Predicate<? super T,E> predicate)` Removes the if.
`<E extends Exception> void`	`replaceAll(Try.BiFunction<? super T,? super Integer,Integer,E> function)` The associated elements will be removed if zero or negative occurrences are returned by the specified `function`.
`<E extends Exception> boolean`	`replaceIf(Try.BiPredicate<? super T,? super Integer,E> predicate, int newOccurrences)`
`<E extends Exception> boolean`	`replaceIf(Try.Predicate<? super T,E> predicate, int newOccurrences)`
`boolean`	`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
`Multiset<T>`	`set(T e, int occurrences)` The element will be removed if the specified count is 0.
`Multiset<T>`	`setAll(Collection<? extends T> c, int occurrences)` Sets the all.
`Multiset<T>`	`setAll(Map<? extends T,Integer> m)` Sets the all.
`Multiset<T>`	`setAll(Multiset<? extends T> multiset)` Sets the all.
`int`	`setAndGet(T e, int occurrences)` The element will be removed if the specified count is 0.
`int`	`size()`
`Stream<T>`	`stream()`
`long`	`sumOfOccurrences()` Sum of occurrences.
`Object[]`	`toArray()`
`<A> A[]`	`toArray(A[] a)`
`ImmutableMap<T,Integer>`	`toImmutableMap()` To immutable map.
`ImmutableMap<T,Integer>`	`toImmutableMap(IntFunction<? extends Map<T,Integer>> mapSupplier)` To immutable map.
`Map<T,Integer>`	`toMap()`
`<M extends Map<T,Integer>> M`	`toMap(IntFunction<? extends M> supplier)`
`Map<T,Integer>`	`toMapSortedByKey(Comparator<? super T> cmp)` To map sorted by key.
`Map<T,Integer>`	`toMapSortedByOccurrences()` To map sorted by occurrences.
`Map<T,Integer>`	`toMapSortedByOccurrences(Comparator<? super Integer> cmp)` To map sorted by occurrences.
`String`	`toString()`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Constructor Detail
- Multiset
```
public Multiset()
```
  Instantiates a new multiset.
- Multiset
```
public Multiset(int initialCapacity)
```
  Instantiates a new multiset.
  
  Parameters:
  
  initialCapacity -
- Multiset
```
public Multiset(Collection<? extends T> c)
```
  Instantiates a new multiset.
  
  Parameters:
  
  c -
- Multiset
```
public Multiset(Class<? extends Map> valueMapType)
```
  Instantiates a new multiset.
  
  Parameters:
  
  valueMapType -
- Multiset
```
public Multiset(Supplier<? extends Map<T,?>> mapSupplier)
```
  Instantiates a new multiset.
  
  Parameters:
  
  mapSupplier -

Method Detail

of

@SafeVarargs
public static <T> Multiset<T> of(T... a)

Type Parameters:: T -
Parameters:: a -
Returns:

from

public static <T> Multiset<T> from(Collection<? extends T> coll)

Type Parameters:: T -
Parameters:: coll -
Returns:

from

public static <T> Multiset<T> from(Map<? extends T,Integer> m)

Type Parameters:: T -
Parameters:: m -
Returns:

get
```
public int get(Object e)
```
Parameters:

e -

Returns:

getOrDefault

public int getOrDefault(Object e,
                        int defaultValue)

Gets the or default.

Parameters:: e -; defaultValue -
Returns:

getAndSet
```
public int getAndSet(T e,
                     int occurrences)
```
The element will be removed if the specified count is 0.

Parameters:

e -

occurrences -

Returns:

setAndGet
```
public int setAndGet(T e,
                     int occurrences)
```
The element will be removed if the specified count is 0.

Parameters:

e -

occurrences -

Returns:

set
```
public Multiset<T> set(T e,
                       int occurrences)
```
The element will be removed if the specified count is 0.

Parameters:

e -

occurrences -

Returns:

this Multiset.

Throws:

IllegalArgumentException - if the occurrences of element is less than 0

setAll

public Multiset<T> setAll(Collection<? extends T> c,
                          int occurrences)

Sets the all.

Parameters:: c -; occurrences -
Returns:

setAll
```
public Multiset<T> setAll(Map<? extends T,Integer> m)
                   throws IllegalArgumentException
```
Sets the all.

Parameters:

m -

Returns:

this Multiset.

Throws:

IllegalArgumentException - if the occurrences of element is less than 0.

setAll
```
public Multiset<T> setAll(Multiset<? extends T> multiset)
                   throws IllegalArgumentException
```
Sets the all.

Parameters:

multiset -

Returns:

this Multiset.

Throws:

IllegalArgumentException - if the occurrences of element is less than 0.

occurrencesOf
```
public int occurrencesOf(Object e)
```
Parameters:

e -

Returns:

minOccurrences

public u.Optional<Pair<T,Integer>> minOccurrences()

Returns:

maxOccurrences

public u.Optional<Pair<T,Integer>> maxOccurrences()

Returns:

allMinOccurrences

public u.Optional<Pair<List<T>,Integer>> allMinOccurrences()

All min occurrences.

Returns:

allMaxOccurrences

public u.Optional<Pair<List<T>,Integer>> allMaxOccurrences()

All max occurrences.

Returns:

sumOfOccurrences
```
public long sumOfOccurrences()
```
Sum of occurrences.

Returns:

Throws:

ArithmeticException - if total occurrences overflows the maximum value of int.

averageOfOccurrences

public u.OptionalDouble averageOfOccurrences()

Average of occurrences.

Returns:

add
```
public boolean add(T e)
            throws IllegalArgumentException
```
Parameters:

e -

Returns:

always true

Throws:

IllegalArgumentException - if the occurrences of element after this operation is bigger than Integer.MAX_VALUE.

add
```
public boolean add(T e,
                   int occurrences)
            throws IllegalArgumentException
```
Parameters:

e -

occurrences -

Returns:

true if the specified occurrences is bigger than 0.

Throws:

IllegalArgumentException - if the occurrences of element after this operation is bigger than Integer.MAX_VALUE.

addIfAbsent
```
public boolean addIfAbsent(T e)
                    throws IllegalArgumentException
```
Adds the if absent.

Parameters:

e -

Returns:

true if the specified element is absent.

Throws:

IllegalArgumentException - the illegal argument exception

addIfAbsent
```
public boolean addIfAbsent(T e,
                           int occurrences)
                    throws IllegalArgumentException
```
Adds the if absent.

Parameters:

e -

occurrences -

Returns:

true if the specified element is absent and occurrences is bigger than 0.

Throws:

IllegalArgumentException - the illegal argument exception

addAndGet
```
public int addAndGet(T e)
```
Adds the and get.

Parameters:

e -

Returns:

addAndGet

public int addAndGet(T e,
                     int occurrences)

Adds the and get.

Parameters:: e -; occurrences -
Returns:

getAndAdd
```
public int getAndAdd(T e)
```
Gets the and add.

Parameters:

e -

Returns:

getAndAdd

public int getAndAdd(T e,
                     int occurrences)

Gets the and add.

Parameters:: e -; occurrences -
Returns:

addAll
```
public boolean addAll(Collection<? extends T> c)
               throws IllegalArgumentException
```
Adds the all.

Parameters:

c -

Returns:

true, if successful

Throws:

IllegalArgumentException - if the occurrences of element after this operation is bigger than Integer.MAX_VALUE.

addAll
```
public boolean addAll(Collection<? extends T> c,
                      int occurrences)
               throws IllegalArgumentException
```
Adds the all.

Parameters:

c -

occurrences -

Returns:

true, if successful

Throws:

IllegalArgumentException - if the occurrences of element after this operation is bigger than Integer.MAX_VALUE.

addAll
```
public boolean addAll(Map<? extends T,Integer> m)
               throws IllegalArgumentException
```
Adds the all.

Parameters:

m -

Returns:

true, if successful

Throws:

IllegalArgumentException - if the occurrences of element after this operation is bigger than Integer.MAX_VALUE.

addAll
```
public boolean addAll(Multiset<? extends T> multiset)
               throws IllegalArgumentException
```
Adds the all.

Parameters:

multiset -

Returns:

true, if successful

Throws:

IllegalArgumentException - if the occurrences of element is less than 0.

contains
```
public boolean contains(Object o)
```
Parameters:

o -

Returns:

true, if successful

containsAll
```
public boolean containsAll(Collection<?> c)
```
Parameters:

c -

Returns:

true, if successful

remove
```
public boolean remove(Object e)
```
Remove one occurrence from the specified elements. The element will be removed from this Multiset if the occurrences equals to or less than 0 after the operation.

Parameters:

e -

Returns:

true, if successful

remove
```
public boolean remove(Object e,
                      int occurrences)
```
Remove the specified occurrences from the specified element. The element will be removed from this Multiset if the occurrences equals to or less than 0 after the operation.

Parameters:

e -

occurrences -

Returns:

true, if successful

removeAndGet
```
public int removeAndGet(Object e)
```
Removes the and get.

Parameters:

e -

Returns:

removeAndGet

public int removeAndGet(Object e,
                        int occurrences)

Removes the and get.

Parameters:: e -; occurrences -
Returns:

getAndRemove
```
public int getAndRemove(Object e)
```
Gets the and remove.

Parameters:

e -

Returns:

getAndRemove

public int getAndRemove(Object e,
                        int occurrences)

Gets the and remove.

Parameters:: e -; occurrences -
Returns:

removeAllOccurrences
```
public int removeAllOccurrences(Object e)
```
Removes the all occurrences.

Parameters:

e -

Returns:

removeAllOccurrencesIf

public <E extends Exception> boolean removeAllOccurrencesIf(Try.Predicate<? super T,E> predicate)
                                                     throws E extends Exception

Removes the all occurrences if.

Type Parameters:: E -
Parameters:: predicate -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

removeAllOccurrencesIf

public <E extends Exception> boolean removeAllOccurrencesIf(Try.BiPredicate<? super T,? super Integer,E> predicate)
                                                     throws E extends Exception

Removes the all occurrences if.

Type Parameters:: E -
Parameters:: predicate -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

removeIf

public <E extends Exception> boolean removeIf(int occurrences,
                                              Try.Predicate<? super T,E> predicate)
                                       throws E extends Exception

Removes the if.

Type Parameters:: E -
Parameters:: occurrences -; predicate -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

removeIf

public <E extends Exception> boolean removeIf(int occurrences,
                                              Try.BiPredicate<? super T,? super Integer,E> predicate)
                                       throws E extends Exception

Removes the if.

Type Parameters:: E -
Parameters:: occurrences -; predicate -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

removeAll
```
public boolean removeAll(Collection<?> c)
```
Removes all of this Multiset's elements that are also contained in the specified collection (optional operation). After this call returns, this Multiset will contain no elements in common with the specified collection. This method ignores how often any element might appear in c, and only cares whether or not an element appears at all.

Parameters:

c -

Returns:

true if this set changed as a result of the call

See Also:

Collection.removeAll(Collection)

removeAll
```
public boolean removeAll(Collection<?> c,
                         int occurrences)
```
Remove the specified occurrences from the specified elements. The elements will be removed from this set if the occurrences equals to or less than 0 after the operation.

Parameters:

c -

occurrences - the occurrences to remove if the element is in the specified collection c.

Returns:

true if this set changed as a result of the call

removeAll
```
public boolean removeAll(Map<?,Integer> m)
```
Removes the all.

Parameters:

m -

Returns:

true, if successful

removeAll
```
public boolean removeAll(Multiset<?> multiset)
                  throws IllegalArgumentException
```
Removes the all.

Parameters:

multiset -

Returns:

true, if successful

Throws:

IllegalArgumentException - the illegal argument exception

replaceIf

public <E extends Exception> boolean replaceIf(Try.Predicate<? super T,E> predicate,
                                               int newOccurrences)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -; newOccurrences -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

replaceIf

public <E extends Exception> boolean replaceIf(Try.BiPredicate<? super T,? super Integer,E> predicate,
                                               int newOccurrences)
                                        throws E extends Exception

Type Parameters:: E -
Parameters:: predicate -; newOccurrences -
Returns:: true, if successful
Throws:: E - the e; E extends Exception

replaceAll
```
public <E extends Exception> void replaceAll(Try.BiFunction<? super T,? super Integer,Integer,E> function)
                                      throws E extends Exception
```
The associated elements will be removed if zero or negative occurrences are returned by the specified function.

Type Parameters:

E -

Parameters:

function -

Throws:

E - the e

E extends Exception

retainAll
```
public boolean retainAll(Collection<?> c)
```
Retains only the elements in this collection that are contained in the specified collection (optional operation). In other words, removes from this collection all of its elements that are not contained in the specified collection.

Parameters:

c -

Returns:

true if this set changed as a result of the call

See Also:

Collection.retainAll(Collection)

copy
```
public Multiset<T> copy()
```
Returns:

elements
```
public Set<T> elements()
```
Returns:

size
```
public int size()
```
Returns:

isEmpty
```
public boolean isEmpty()
```
Checks if is empty.

Returns:

true, if is empty

clear
```
public void clear()
```
Clear.

iterator
```
public Iterator<T> iterator()
```
Specified by:

iterator in interface Iterable<T>

Returns:

toArray
```
public Object[] toArray()
```
Returns:

toArray
```
public <A> A[] toArray(A[] a)
```
Type Parameters:

A -

Parameters:

a -

Returns:

toMap
```
public Map<T,Integer> toMap()
```
Returns:

toMap

public <M extends Map<T,Integer>> M toMap(IntFunction<? extends M> supplier)

Type Parameters:: M -
Parameters:: supplier -
Returns:

toMapSortedByOccurrences
```
public Map<T,Integer> toMapSortedByOccurrences()
```
To map sorted by occurrences.

Returns:

toMapSortedByOccurrences

public Map<T,Integer> toMapSortedByOccurrences(Comparator<? super Integer> cmp)

To map sorted by occurrences.

Parameters:: cmp -
Returns:

toMapSortedByKey

public Map<T,Integer> toMapSortedByKey(Comparator<? super T> cmp)

To map sorted by key.

Parameters:: cmp -
Returns:

toImmutableMap

public ImmutableMap<T,Integer> toImmutableMap()

To immutable map.

Returns:

toImmutableMap

public ImmutableMap<T,Integer> toImmutableMap(IntFunction<? extends Map<T,Integer>> mapSupplier)

To immutable map.

Parameters:: mapSupplier -
Returns:

flatten
```
public List<T> flatten()
```
Returns:

a list with all elements, each of them is repeated with the occurrences in this Multiset

filter

public <E extends Exception> Multiset<T> filter(Try.Predicate<? super T,E> filter)
                                         throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:
Throws:: E - the e; E extends Exception

filter

public <E extends Exception> Multiset<T> filter(Try.BiPredicate<? super T,Integer,E> filter)
                                         throws E extends Exception

Type Parameters:: E -
Parameters:: filter -
Returns:
Throws:: E - the e; E extends Exception

forEach

public <E extends Exception> void forEach(Try.Consumer<? super T,E> action)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

forEach

public <E extends Exception> void forEach(Try.ObjIntConsumer<? super T,E> action)
                                   throws E extends Exception

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

computeIfAbsent

public <E extends Exception> int computeIfAbsent(T e,
                                                 Try.Function<? super T,Integer,E> mappingFunction)
                                          throws E extends Exception

The implementation is equivalent to performing the following steps for this Multiset:

 final int oldValue = get(e);
 
 if (oldValue > 0) {
     return oldValue;
 }
 
 final int newValue = mappingFunction.apply(e);
 
 if (newValue > 0) {
     set(e, newValue);
 }
 
 return newValue;

Type Parameters:: E -
Parameters:: e -; mappingFunction -
Returns:
Throws:: E - the e; E extends Exception

computeIfPresent

public <E extends Exception> int computeIfPresent(T e,
                                                  Try.BiFunction<? super T,Integer,Integer,E> remappingFunction)
                                           throws E extends Exception

The implementation is equivalent to performing the following steps for this Multiset:

 
 final int oldValue = get(e);
 
 if (oldValue == 0) {
     return oldValue;
 }
 
 final int newValue = remappingFunction.apply(e, oldValue);
 
 if (newValue > 0) {
     set(e, newValue);
 } else {
     remove(e);
 }
 
 return newValue;

Type Parameters:: E -
Parameters:: e -; remappingFunction -
Returns:
Throws:: E - the e; E extends Exception

compute

public <E extends Exception> int compute(T key,
                                         Try.BiFunction<? super T,Integer,Integer,E> remappingFunction)
                                  throws E extends Exception

The implementation is equivalent to performing the following steps for this Multiset:

 final int oldValue = get(key);
 final int newValue = remappingFunction.apply(key, oldValue);
 
 if (newValue > 0) {
     set(key, newValue);
 } else {
     if (oldValue > 0) {
         remove(key);
     }
 }
 
 return newValue;

Type Parameters:: E -
Parameters:: key -; remappingFunction -
Returns:
Throws:: E - the e; E extends Exception

merge

public <E extends Exception> int merge(T key,
                                       int value,
                                       Try.BiFunction<Integer,Integer,Integer,E> remappingFunction)
                                throws E extends Exception

The implementation is equivalent to performing the following steps for this Multiset:

 int oldValue = get(key);
 int newValue = (oldValue == 0) ? value : remappingFunction.apply(oldValue, value);
 
 if (newValue > 0) {
     set(key, newValue);
 } else {
     if (oldValue > 0) {
         remove(key);
     }
 }
 
 return newValue;

Type Parameters:: E -
Parameters:: key -; value -; remappingFunction -
Returns:
Throws:: E - the e; E extends Exception

stream
```
public Stream<T> stream()
```
Returns:

flatStream
```
public Stream<T> flatStream()
```
Returns:

entryStream

public EntryStream<T,Integer> entryStream()

Returns:

apply

public <R,E extends Exception> R apply(Try.Function<? super Multiset<T>,R,E> func)
                                throws E extends Exception

Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

applyIfNotEmpty

public <R,E extends Exception> u.Optional<R> applyIfNotEmpty(Try.Function<? super Multiset<T>,R,E> func)
                                                      throws E extends Exception

Apply if not empty.

Type Parameters:: R -; E -
Parameters:: func -
Returns:
Throws:: E - the e; E extends Exception

accept

public <E extends Exception> void accept(Try.Consumer<? super Multiset<T>,E> action)
                                  throws E extends Exception

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

acceptIfNotEmpty

public <E extends Exception> void acceptIfNotEmpty(Try.Consumer<? super Multiset<T>,E> action)
                                            throws E extends Exception

Accept if not empty.

Type Parameters:: E -
Parameters:: action -
Throws:: E - the e; E extends Exception

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

Returns:

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

Parameters:

obj -

Returns:

true, if successful

toString
```
public String toString()
```
Overrides:

toString in class Object

Returns:

Class Multiset<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

Multiset

Multiset

Multiset

Multiset

Multiset

Method Detail

of

from

from

get

getOrDefault

getAndSet

setAndGet

set

setAll

setAll

setAll

occurrencesOf

minOccurrences

maxOccurrences

allMinOccurrences

allMaxOccurrences

sumOfOccurrences

averageOfOccurrences

add

add

addIfAbsent

addIfAbsent

addAndGet

addAndGet

getAndAdd

getAndAdd

addAll

addAll

addAll

addAll

contains

containsAll

remove

remove

removeAndGet

removeAndGet

getAndRemove

getAndRemove

removeAllOccurrences

removeAllOccurrencesIf

removeAllOccurrencesIf

removeIf

removeIf

removeAll

removeAll

removeAll

removeAll

replaceIf

replaceIf

replaceAll

retainAll

copy

elements

size

isEmpty

clear

iterator

toArray

toArray

toMap

toMap

toMapSortedByOccurrences

toMapSortedByOccurrences

toMapSortedByKey

toImmutableMap

toImmutableMap

flatten

filter