java.lang.Object
- org.eclipse.collections.impl.collection.mutable.AbstractUnmodifiableMutableCollection<T>
- - org.eclipse.collections.impl.bag.mutable.UnmodifiableBag<T>

All Implemented Interfaces:

Serializable, Iterable<T>, Collection<T>, Bag<T>, MutableBag<T>, MutableBagIterable<T>, UnsortedBag<T>, MutableCollection<T>, InternalIterable<T>, RichIterable<T>
```
public class UnmodifiableBag<T>
extends AbstractUnmodifiableMutableCollection<T>
implements MutableBag<T>, Serializable
```
An unmodifiable view of a bag.

Since:

1.0

See Also:

MutableBag.asUnmodifiable(), Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`int`	`addOccurrences(T item, int occurrences)`
`boolean`	`allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`boolean`	`anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`MutableBag<T>`	`asSynchronized()`
`MutableBag<T>`	`asUnmodifiable()`
`MutableList<ObjectIntPair<T>>`	`bottomOccurrences(int count)`
`<V> MutableBag<V>`	`collect(Function<? super T,? extends V> function)`
`MutableBooleanBag`	`collectBoolean(BooleanFunction<? super T> booleanFunction)`
`MutableByteBag`	`collectByte(ByteFunction<? super T> byteFunction)`
`MutableCharBag`	`collectChar(CharFunction<? super T> charFunction)`
`MutableDoubleBag`	`collectDouble(DoubleFunction<? super T> doubleFunction)`
`MutableFloatBag`	`collectFloat(FloatFunction<? super T> floatFunction)`
`<V> MutableBag<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`MutableIntBag`	`collectInt(IntFunction<? super T> intFunction)`
`MutableLongBag`	`collectLong(LongFunction<? super T> longFunction)`
`MutableShortBag`	`collectShort(ShortFunction<? super T> shortFunction)`
`<P,A> MutableBag<A>`	`collectWith(Function2<? super T,? super P,? extends A> function, P parameter)`
`<V> MutableBag<V>`	`collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function, R target)`
`T`	`detectWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`RichIterable<T>`	`distinctView()`
`boolean`	`equals(Object obj)`
`<V> MutableBag<V>`	`flatCollect(Function<? super T,? extends Iterable<V>> function)`
`void`	`forEachWithOccurrences(ObjectIntProcedure<? super T> objectIntProcedure)`
`<V> MutableBagMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)`
`<V> MutableBagMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)`
`int`	`hashCode()`
`MutableBag<T>`	`newEmpty()`
`boolean`	`noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`int`	`occurrencesOf(Object item)`
`static <E,B extends MutableBag<E>> UnmodifiableBag<E>`	`of(B bag)`	This method will take a MutableBag and wrap it directly in a UnmodifiableBag.
`PartitionMutableBag<T>`	`partition(Predicate<? super T> predicate)`
`<P> PartitionMutableBag<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`
`MutableBag<T>`	`reject(Predicate<? super T> predicate)`
`<P> MutableBag<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`removeOccurrences(Object item, int occurrences)`
`MutableBag<T>`	`select(Predicate<? super T> predicate)`
`MutableBag<T>`	`selectByOccurrences(IntPredicate predicate)`
`<S> MutableBag<S>`	`selectInstancesOf(Class<S> clazz)`
`MutableSet<T>`	`selectUnique()`
`<P> MutableBag<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`setOccurrences(T item, int occurrences)`
`int`	`sizeDistinct()`
`<V> MutableObjectLongMap<V>`	`sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)`
`<V> MutableObjectLongMap<V>`	`sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)`
`MutableBag<T>`	`tap(Procedure<? super T> procedure)`
`ImmutableBag<T>`	`toImmutable()`
`MutableMap<T,Integer>`	`toMapOfItemToCount()`
`MutableList<ObjectIntPair<T>>`	`topOccurrences(int count)`
`String`	`toStringOfItemToCount()`
`MutableBag<T>`	`with(T element)`
`MutableBag<T>`	`withAll(Iterable<? extends T> elements)`
`MutableBag<T>`	`without(T element)`
`MutableBag<T>`	`withoutAll(Iterable<? extends T> elements)`
`<S> MutableBag<Pair<T,S>>`	`zip(Iterable<S> that)`	Deprecated. in 6.0.
`MutableSet<Pair<T,Integer>>`	`zipWithIndex()`	Deprecated. in 6.0.

Methods inherited from class org.eclipse.collections.impl.collection.mutable.AbstractUnmodifiableMutableCollection
add, addAll, addAllIterable, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, clear, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsNone, containsNoneIterable, count, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, forEachWith, forEachWithIndex, getFirst, getLast, getOnly, groupBy, groupByEach, groupByUniqueKey, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoWith, into, isEmpty, iterator, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterable, select, selectAndRejectWith, selectWith, size, sumByDouble, sumByFloat, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedList, toSortedList, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toString, zip, zipWithIndex

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

Methods inherited from interface org.eclipse.collections.api.bag.Bag
aggregateBy, reduceInPlace, reduceInPlace, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong

Methods inherited from interface java.util.Collection
add, addAll, clear, contains, containsAll, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, stream, toArray, toArray, toArray

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex

Methods inherited from interface org.eclipse.collections.api.bag.MutableBag
countBy, countByEach, countByWith, flatCollectWith, selectDuplicates, toImmutableBag

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection
addAllIterable, aggregateBy, aggregateInPlaceBy, flatCollectWith, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith, sumByDouble, sumByFloat

Methods inherited from interface org.eclipse.collections.api.RichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, into, isEmpty, makeString, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

- Method Detail
  - of
```
public static <E,B extends MutableBag<E>> UnmodifiableBag<E> of(B bag)
```
    This method will take a MutableBag and wrap it directly in a UnmodifiableBag.
  - asUnmodifiable
```
public MutableBag<T> asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableBag<T>
    
    Specified by:
    
    asUnmodifiable in interface MutableCollection<T>
    
    Overrides:
    
    asUnmodifiable in class AbstractUnmodifiableMutableCollection<T>
  - asSynchronized
```
public MutableBag<T> asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableBag<T>
    
    Specified by:
    
    asSynchronized in interface MutableCollection<T>
    
    Overrides:
    
    asSynchronized in class AbstractUnmodifiableMutableCollection<T>
  - toImmutable
```
public ImmutableBag<T> toImmutable()
```
    Specified by:
    
    toImmutable in interface Bag<T>
    
    Specified by:
    
    toImmutable in interface MutableBag<T>
    
    Specified by:
    
    toImmutable in interface MutableCollection<T>
    
    Overrides:
    
    toImmutable in class AbstractUnmodifiableMutableCollection<T>
  - equals
```
public boolean equals(Object obj)
```
    Specified by:
    
    equals in interface Bag<T>
    
    Specified by:
    
    equals in interface Collection<T>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Bag<T>
    
    Specified by:
    
    hashCode in interface Collection<T>
    
    Overrides:
    
    hashCode in class Object
  - toStringOfItemToCount
```
public String toStringOfItemToCount()
```
    Specified by:
    
    toStringOfItemToCount in interface Bag<T>
  - newEmpty
```
public MutableBag<T> newEmpty()
```
    Specified by:
    
    newEmpty in interface MutableBag<T>
    
    Specified by:
    
    newEmpty in interface MutableCollection<T>
    
    Overrides:
    
    newEmpty in class AbstractUnmodifiableMutableCollection<T>
  - selectByOccurrences
```
public MutableBag<T> selectByOccurrences(IntPredicate predicate)
```
    Specified by:
    
    selectByOccurrences in interface Bag<T>
    
    Specified by:
    
    selectByOccurrences in interface MutableBag<T>
    
    Specified by:
    
    selectByOccurrences in interface MutableBagIterable<T>
    
    Specified by:
    
    selectByOccurrences in interface UnsortedBag<T>
  - tap
```
public MutableBag<T> tap(Procedure<? super T> procedure)
```
    Specified by:
    
    tap in interface Bag<T>
    
    Specified by:
    
    tap in interface MutableBag<T>
    
    Specified by:
    
    tap in interface MutableBagIterable<T>
    
    Specified by:
    
    tap in interface MutableCollection<T>
    
    Specified by:
    
    tap in interface RichIterable<T>
    
    Specified by:
    
    tap in interface UnsortedBag<T>
    
    Overrides:
    
    tap in class AbstractUnmodifiableMutableCollection<T>
  - select
```
public MutableBag<T> select(Predicate<? super T> predicate)
```
    Specified by:
    
    select in interface Bag<T>
    
    Specified by:
    
    select in interface MutableBag<T>
    
    Specified by:
    
    select in interface MutableBagIterable<T>
    
    Specified by:
    
    select in interface MutableCollection<T>
    
    Specified by:
    
    select in interface RichIterable<T>
    
    Specified by:
    
    select in interface UnsortedBag<T>
    
    Overrides:
    
    select in class AbstractUnmodifiableMutableCollection<T>
  - selectWith
```
public <P> MutableBag<T> selectWith(Predicate2<? super T,? super P> predicate,
                                    P parameter)
```
    Specified by:
    
    selectWith in interface Bag<T>
    
    Specified by:
    
    selectWith in interface MutableBag<T>
    
    Specified by:
    
    selectWith in interface MutableBagIterable<T>
    
    Specified by:
    
    selectWith in interface MutableCollection<T>
    
    Specified by:
    
    selectWith in interface RichIterable<T>
    
    Specified by:
    
    selectWith in interface UnsortedBag<T>
    
    Overrides:
    
    selectWith in class AbstractUnmodifiableMutableCollection<T>
  - reject
```
public MutableBag<T> reject(Predicate<? super T> predicate)
```
    Specified by:
    
    reject in interface Bag<T>
    
    Specified by:
    
    reject in interface MutableBag<T>
    
    Specified by:
    
    reject in interface MutableBagIterable<T>
    
    Specified by:
    
    reject in interface MutableCollection<T>
    
    Specified by:
    
    reject in interface RichIterable<T>
    
    Specified by:
    
    reject in interface UnsortedBag<T>
    
    Overrides:
    
    reject in class AbstractUnmodifiableMutableCollection<T>
  - rejectWith
```
public <P> MutableBag<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                    P parameter)
```
    Specified by:
    
    rejectWith in interface Bag<T>
    
    Specified by:
    
    rejectWith in interface MutableBag<T>
    
    Specified by:
    
    rejectWith in interface MutableBagIterable<T>
    
    Specified by:
    
    rejectWith in interface MutableCollection<T>
    
    Specified by:
    
    rejectWith in interface RichIterable<T>
    
    Specified by:
    
    rejectWith in interface UnsortedBag<T>
    
    Overrides:
    
    rejectWith in class AbstractUnmodifiableMutableCollection<T>
  - partition
```
public PartitionMutableBag<T> partition(Predicate<? super T> predicate)
```
    Specified by:
    
    partition in interface Bag<T>
    
    Specified by:
    
    partition in interface MutableBag<T>
    
    Specified by:
    
    partition in interface MutableBagIterable<T>
    
    Specified by:
    
    partition in interface MutableCollection<T>
    
    Specified by:
    
    partition in interface RichIterable<T>
    
    Specified by:
    
    partition in interface UnsortedBag<T>
    
    Overrides:
    
    partition in class AbstractUnmodifiableMutableCollection<T>
  - partitionWith
```
public <P> PartitionMutableBag<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                P parameter)
```
    Specified by:
    
    partitionWith in interface Bag<T>
    
    Specified by:
    
    partitionWith in interface MutableBag<T>
    
    Specified by:
    
    partitionWith in interface MutableBagIterable<T>
    
    Specified by:
    
    partitionWith in interface MutableCollection<T>
    
    Specified by:
    
    partitionWith in interface RichIterable<T>
    
    Overrides:
    
    partitionWith in class AbstractUnmodifiableMutableCollection<T>
  - selectInstancesOf
```
public <S> MutableBag<S> selectInstancesOf(Class<S> clazz)
```
    Specified by:
    
    selectInstancesOf in interface Bag<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableBag<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableBagIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableCollection<T>
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface UnsortedBag<T>
    
    Overrides:
    
    selectInstancesOf in class AbstractUnmodifiableMutableCollection<T>
  - collect
```
public <V> MutableBag<V> collect(Function<? super T,? extends V> function)
```
    Specified by:
    
    collect in interface MutableBag<T>
    
    Specified by:
    
    collect in interface MutableCollection<T>
    
    Specified by:
    
    collect in interface RichIterable<T>
    
    Specified by:
    
    collect in interface UnsortedBag<T>
    
    Overrides:
    
    collect in class AbstractUnmodifiableMutableCollection<T>
  - collectBoolean
```
public MutableBooleanBag collectBoolean(BooleanFunction<? super T> booleanFunction)
```
    Specified by:
    
    collectBoolean in interface MutableBag<T>
    
    Specified by:
    
    collectBoolean in interface MutableCollection<T>
    
    Specified by:
    
    collectBoolean in interface RichIterable<T>
    
    Specified by:
    
    collectBoolean in interface UnsortedBag<T>
    
    Overrides:
    
    collectBoolean in class AbstractUnmodifiableMutableCollection<T>
  - collectByte
```
public MutableByteBag collectByte(ByteFunction<? super T> byteFunction)
```
    Specified by:
    
    collectByte in interface MutableBag<T>
    
    Specified by:
    
    collectByte in interface MutableCollection<T>
    
    Specified by:
    
    collectByte in interface RichIterable<T>
    
    Specified by:
    
    collectByte in interface UnsortedBag<T>
    
    Overrides:
    
    collectByte in class AbstractUnmodifiableMutableCollection<T>
  - collectChar
```
public MutableCharBag collectChar(CharFunction<? super T> charFunction)
```
    Specified by:
    
    collectChar in interface MutableBag<T>
    
    Specified by:
    
    collectChar in interface MutableCollection<T>
    
    Specified by:
    
    collectChar in interface RichIterable<T>
    
    Specified by:
    
    collectChar in interface UnsortedBag<T>
    
    Overrides:
    
    collectChar in class AbstractUnmodifiableMutableCollection<T>
  - collectDouble
```
public MutableDoubleBag collectDouble(DoubleFunction<? super T> doubleFunction)
```
    Specified by:
    
    collectDouble in interface MutableBag<T>
    
    Specified by:
    
    collectDouble in interface MutableCollection<T>
    
    Specified by:
    
    collectDouble in interface RichIterable<T>
    
    Specified by:
    
    collectDouble in interface UnsortedBag<T>
    
    Overrides:
    
    collectDouble in class AbstractUnmodifiableMutableCollection<T>
  - collectFloat
```
public MutableFloatBag collectFloat(FloatFunction<? super T> floatFunction)
```
    Specified by:
    
    collectFloat in interface MutableBag<T>
    
    Specified by:
    
    collectFloat in interface MutableCollection<T>
    
    Specified by:
    
    collectFloat in interface RichIterable<T>
    
    Specified by:
    
    collectFloat in interface UnsortedBag<T>
    
    Overrides:
    
    collectFloat in class AbstractUnmodifiableMutableCollection<T>
  - collectInt
```
public MutableIntBag collectInt(IntFunction<? super T> intFunction)
```
    Specified by:
    
    collectInt in interface MutableBag<T>
    
    Specified by:
    
    collectInt in interface MutableCollection<T>
    
    Specified by:
    
    collectInt in interface RichIterable<T>
    
    Specified by:
    
    collectInt in interface UnsortedBag<T>
    
    Overrides:
    
    collectInt in class AbstractUnmodifiableMutableCollection<T>
  - collectLong
```
public MutableLongBag collectLong(LongFunction<? super T> longFunction)
```
    Specified by:
    
    collectLong in interface MutableBag<T>
    
    Specified by:
    
    collectLong in interface MutableCollection<T>
    
    Specified by:
    
    collectLong in interface RichIterable<T>
    
    Specified by:
    
    collectLong in interface UnsortedBag<T>
    
    Overrides:
    
    collectLong in class AbstractUnmodifiableMutableCollection<T>
  - collectShort
```
public MutableShortBag collectShort(ShortFunction<? super T> shortFunction)
```
    Specified by:
    
    collectShort in interface MutableBag<T>
    
    Specified by:
    
    collectShort in interface MutableCollection<T>
    
    Specified by:
    
    collectShort in interface RichIterable<T>
    
    Specified by:
    
    collectShort in interface UnsortedBag<T>
    
    Overrides:
    
    collectShort in class AbstractUnmodifiableMutableCollection<T>
  - flatCollect
```
public <V> MutableBag<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    flatCollect in interface MutableBag<T>
    
    Specified by:
    
    flatCollect in interface MutableCollection<T>
    
    Specified by:
    
    flatCollect in interface RichIterable<T>
    
    Specified by:
    
    flatCollect in interface UnsortedBag<T>
    
    Overrides:
    
    flatCollect in class AbstractUnmodifiableMutableCollection<T>
  - topOccurrences
```
public MutableList<ObjectIntPair<T>> topOccurrences(int count)
```
    Specified by:
    
    topOccurrences in interface Bag<T>
    
    Specified by:
    
    topOccurrences in interface MutableBagIterable<T>
  - bottomOccurrences
```
public MutableList<ObjectIntPair<T>> bottomOccurrences(int count)
```
    Specified by:
    
    bottomOccurrences in interface Bag<T>
    
    Specified by:
    
    bottomOccurrences in interface MutableBagIterable<T>
  - collectWithOccurrences
```
public <V> MutableBag<V> collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function)
```
    Specified by:
    
    collectWithOccurrences in interface Bag<T>
    
    Specified by:
    
    collectWithOccurrences in interface MutableBag<T>
    
    Specified by:
    
    collectWithOccurrences in interface MutableBagIterable<T>
    
    Specified by:
    
    collectWithOccurrences in interface UnsortedBag<T>
  - collectWith
```
public <P,A> MutableBag<A> collectWith(Function2<? super T,? super P,? extends A> function,
                                             P parameter)
```
    Specified by:
    
    collectWith in interface MutableBag<T>
    
    Specified by:
    
    collectWith in interface MutableCollection<T>
    
    Specified by:
    
    collectWith in interface RichIterable<T>
    
    Specified by:
    
    collectWith in interface UnsortedBag<T>
    
    Overrides:
    
    collectWith in class AbstractUnmodifiableMutableCollection<T>
  - collectIf
```
public <V> MutableBag<V> collectIf(Predicate<? super T> predicate,
                                   Function<? super T,? extends V> function)
```
    Specified by:
    
    collectIf in interface MutableBag<T>
    
    Specified by:
    
    collectIf in interface MutableCollection<T>
    
    Specified by:
    
    collectIf in interface RichIterable<T>
    
    Specified by:
    
    collectIf in interface UnsortedBag<T>
    
    Overrides:
    
    collectIf in class AbstractUnmodifiableMutableCollection<T>
  - groupBy
```
public <V> MutableBagMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
    Specified by:
    
    groupBy in interface Bag<T>
    
    Specified by:
    
    groupBy in interface MutableBag<T>
    
    Specified by:
    
    groupBy in interface MutableBagIterable<T>
    
    Specified by:
    
    groupBy in interface MutableCollection<T>
    
    Specified by:
    
    groupBy in interface RichIterable<T>
    
    Specified by:
    
    groupBy in interface UnsortedBag<T>
    
    Overrides:
    
    groupBy in class AbstractUnmodifiableMutableCollection<T>
  - groupByEach
```
public <V> MutableBagMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    groupByEach in interface Bag<T>
    
    Specified by:
    
    groupByEach in interface MutableBag<T>
    
    Specified by:
    
    groupByEach in interface MutableBagIterable<T>
    
    Specified by:
    
    groupByEach in interface MutableCollection<T>
    
    Specified by:
    
    groupByEach in interface RichIterable<T>
    
    Specified by:
    
    groupByEach in interface UnsortedBag<T>
    
    Overrides:
    
    groupByEach in class AbstractUnmodifiableMutableCollection<T>
  - addOccurrences
```
public int addOccurrences(T item,
                          int occurrences)
```
    Specified by:
    
    addOccurrences in interface MutableBagIterable<T>
  - removeOccurrences
```
public boolean removeOccurrences(Object item,
                                 int occurrences)
```
    Specified by:
    
    removeOccurrences in interface MutableBagIterable<T>
  - setOccurrences
```
public boolean setOccurrences(T item,
                              int occurrences)
```
    Specified by:
    
    setOccurrences in interface MutableBagIterable<T>
  - sizeDistinct
```
public int sizeDistinct()
```
    Specified by:
    
    sizeDistinct in interface Bag<T>
  - occurrencesOf
```
public int occurrencesOf(Object item)
```
    Specified by:
    
    occurrencesOf in interface Bag<T>
  - forEachWithOccurrences
```
public void forEachWithOccurrences(ObjectIntProcedure<? super T> objectIntProcedure)
```
    Specified by:
    
    forEachWithOccurrences in interface Bag<T>
  - anySatisfyWithOccurrences
```
public boolean anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Specified by:
    
    anySatisfyWithOccurrences in interface Bag<T>
  - allSatisfyWithOccurrences
```
public boolean allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Specified by:
    
    allSatisfyWithOccurrences in interface Bag<T>
  - noneSatisfyWithOccurrences
```
public boolean noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Specified by:
    
    noneSatisfyWithOccurrences in interface Bag<T>
  - detectWithOccurrences
```
public T detectWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Specified by:
    
    detectWithOccurrences in interface Bag<T>
  - collectWithOccurrences
```
public <V,R extends Collection<V>> R collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function,
                                                                  R target)
```
    Specified by:
    
    collectWithOccurrences in interface Bag<T>
    
    Since:
    
    9.1.
  - toMapOfItemToCount
```
public MutableMap<T,Integer> toMapOfItemToCount()
```
    Specified by:
    
    toMapOfItemToCount in interface Bag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface MutableBag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface MutableBagIterable<T>
  - zip
```
@Deprecated
public <S> MutableBag<Pair<T,S>> zip(Iterable<S> that)
```
    Deprecated.
    in 6.0. Use OrderedIterable.zip(Iterable) instead.
    
    Specified by:
    
    zip in interface MutableBag<T>
    
    Specified by:
    
    zip in interface MutableCollection<T>
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Specified by:
    
    zip in interface UnsortedBag<T>
    
    Overrides:
    
    zip in class AbstractUnmodifiableMutableCollection<T>
  - zipWithIndex
```
@Deprecated
public MutableSet<Pair<T,Integer>> zipWithIndex()
```
    Deprecated.
    in 6.0. Use OrderedIterable.zipWithIndex() instead.
    
    Specified by:
    
    zipWithIndex in interface Bag<T>
    
    Specified by:
    
    zipWithIndex in interface MutableBag<T>
    
    Specified by:
    
    zipWithIndex in interface MutableBagIterable<T>
    
    Specified by:
    
    zipWithIndex in interface MutableCollection<T>
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Specified by:
    
    zipWithIndex in interface UnsortedBag<T>
    
    Overrides:
    
    zipWithIndex in class AbstractUnmodifiableMutableCollection<T>
  - with
```
public MutableBag<T> with(T element)
```
    Specified by:
    
    with in interface MutableBag<T>
    
    Specified by:
    
    with in interface MutableBagIterable<T>
    
    Specified by:
    
    with in interface MutableCollection<T>
    
    Overrides:
    
    with in class AbstractUnmodifiableMutableCollection<T>
  - without
```
public MutableBag<T> without(T element)
```
    Specified by:
    
    without in interface MutableBag<T>
    
    Specified by:
    
    without in interface MutableBagIterable<T>
    
    Specified by:
    
    without in interface MutableCollection<T>
    
    Overrides:
    
    without in class AbstractUnmodifiableMutableCollection<T>
  - withAll
```
public MutableBag<T> withAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withAll in interface MutableBag<T>
    
    Specified by:
    
    withAll in interface MutableBagIterable<T>
    
    Specified by:
    
    withAll in interface MutableCollection<T>
    
    Overrides:
    
    withAll in class AbstractUnmodifiableMutableCollection<T>
  - withoutAll
```
public MutableBag<T> withoutAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withoutAll in interface MutableBag<T>
    
    Specified by:
    
    withoutAll in interface MutableBagIterable<T>
    
    Specified by:
    
    withoutAll in interface MutableCollection<T>
    
    Overrides:
    
    withoutAll in class AbstractUnmodifiableMutableCollection<T>
  - selectUnique
```
public MutableSet<T> selectUnique()
```
    Specified by:
    
    selectUnique in interface Bag<T>
    
    Specified by:
    
    selectUnique in interface MutableBag<T>
    
    Specified by:
    
    selectUnique in interface MutableBagIterable<T>
    
    Specified by:
    
    selectUnique in interface UnsortedBag<T>
  - sumByInt
```
public <V> MutableObjectLongMap<V> sumByInt(Function<? super T,? extends V> groupBy,
                                            IntFunction<? super T> function)
```
    Specified by:
    
    sumByInt in interface MutableCollection<T>
    
    Specified by:
    
    sumByInt in interface RichIterable<T>
    
    Overrides:
    
    sumByInt in class AbstractUnmodifiableMutableCollection<T>
  - sumByLong
```
public <V> MutableObjectLongMap<V> sumByLong(Function<? super T,? extends V> groupBy,
                                             LongFunction<? super T> function)
```
    Specified by:
    
    sumByLong in interface MutableCollection<T>
    
    Specified by:
    
    sumByLong in interface RichIterable<T>
    
    Overrides:
    
    sumByLong in class AbstractUnmodifiableMutableCollection<T>
  - distinctView
```
public RichIterable<T> distinctView()
```
    Specified by:
    
    distinctView in interface Bag<T>

Class UnmodifiableBag<T>

Method Summary

Methods inherited from class org.eclipse.collections.impl.collection.mutable.AbstractUnmodifiableMutableCollection

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.bag.Bag

Methods inherited from interface java.util.Collection

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Methods inherited from interface org.eclipse.collections.api.bag.MutableBag

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection

Methods inherited from interface org.eclipse.collections.api.RichIterable

Method Detail

of

asUnmodifiable

asSynchronized

toImmutable

equals

hashCode

toStringOfItemToCount

newEmpty

selectByOccurrences

tap

select

selectWith

reject

rejectWith

partition

partitionWith

selectInstancesOf

collect

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

flatCollect

topOccurrences

bottomOccurrences

collectWithOccurrences

collectWith

collectIf

groupBy

groupByEach

addOccurrences

removeOccurrences

setOccurrences

sizeDistinct

occurrencesOf

forEachWithOccurrences

anySatisfyWithOccurrences

allSatisfyWithOccurrences

noneSatisfyWithOccurrences

detectWithOccurrences

collectWithOccurrences

toMapOfItemToCount

zip

zipWithIndex

with

without

withAll

withoutAll

selectUnique

sumByInt

sumByLong

distinctView