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

All Implemented Interfaces:

Serializable, Cloneable, Comparable<SortedBag<T>>, Iterable<T>, Collection<T>, Bag<T>, MutableBagIterable<T>, MutableSortedBag<T>, SortedBag<T>, MutableCollection<T>, InternalIterable<T>, OrderedIterable<T>, ReversibleIterable<T>, SortedIterable<T>, RichIterable<T>
```
public class UnmodifiableSortedBag<T>
extends AbstractUnmodifiableMutableCollection<T>
implements MutableSortedBag<T>, Serializable
```
An unmodifiable view of a SortedBag.

Since:

4.2

See Also:

MutableSortedBag.asUnmodifiable(), Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`int`	`addOccurrences(T item, int occurrences)`
`boolean`	`allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`boolean`	`anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`LazyIterable<T>`	`asReversed()`
`MutableSortedBag<T>`	`asSynchronized()`
`MutableSortedBag<T>`	`asUnmodifiable()`
`MutableList<ObjectIntPair<T>>`	`bottomOccurrences(int count)`
`UnmodifiableSortedBag<T>`	`clone()`
`<V> MutableList<V>`	`collect(Function<? super T,? extends V> function)`
`MutableBooleanList`	`collectBoolean(BooleanFunction<? super T> booleanFunction)`
`MutableByteList`	`collectByte(ByteFunction<? super T> byteFunction)`
`MutableCharList`	`collectChar(CharFunction<? super T> charFunction)`
`MutableDoubleList`	`collectDouble(DoubleFunction<? super T> doubleFunction)`
`MutableFloatList`	`collectFloat(FloatFunction<? super T> floatFunction)`
`<V> MutableList<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`MutableIntList`	`collectInt(IntFunction<? super T> intFunction)`
`MutableLongList`	`collectLong(LongFunction<? super T> longFunction)`
`MutableShortList`	`collectShort(ShortFunction<? super T> shortFunction)`
`<P,A> MutableList<A>`	`collectWith(Function2<? super T,? super P,? extends A> function, P parameter)`
`<V> MutableList<V>`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function, R target)`
`<V> MutableList<V>`	`collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function, R target)`
`Comparator<? super T>`	`comparator()`
`int`	`compareTo(SortedBag<T> o)`
`<S> boolean`	`corresponds(OrderedIterable<S> other, Predicate2<? super T,? super S> predicate)`
`int`	`detectIndex(Predicate<? super T> predicate)`
`int`	`detectLastIndex(Predicate<? super T> predicate)`
`T`	`detectWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`MutableSortedSet<T>`	`distinct()`
`RichIterable<T>`	`distinctView()`
`MutableSortedBag<T>`	`drop(int count)`
`MutableSortedBag<T>`	`dropWhile(Predicate<? super T> predicate)`
`boolean`	`equals(Object obj)`
`<V> MutableList<V>`	`flatCollect(Function<? super T,? extends Iterable<V>> function)`
`void`	`forEach(int startIndex, int endIndex, Procedure<? super T> procedure)`
`void`	`forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super T> objectIntProcedure)`
`void`	`forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)`
`<V> MutableSortedBagMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)`
`<V> MutableSortedBagMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)`
`int`	`hashCode()`
`int`	`indexOf(Object object)`
`MutableSortedBag<T>`	`newEmpty()`
`boolean`	`noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`
`int`	`occurrencesOf(Object item)`
`static <E,S extends MutableSortedBag<E>> UnmodifiableSortedBag<E>`	`of(S bag)`	This method will take a MutableSortedBag and wrap it directly in a UnmodifiableSortedBag.
`PartitionMutableSortedBag<T>`	`partition(Predicate<? super T> predicate)`
`PartitionMutableSortedBag<T>`	`partitionWhile(Predicate<? super T> predicate)`
`<P> PartitionMutableSortedBag<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`
`MutableSortedBag<T>`	`reject(Predicate<? super T> predicate)`
`<P> MutableSortedBag<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`removeOccurrences(Object item, int occurrences)`
`void`	`reverseForEach(Procedure<? super T> procedure)`
`void`	`reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure)`
`MutableSortedBag<T>`	`select(Predicate<? super T> predicate)`
`MutableSortedBag<T>`	`selectByOccurrences(IntPredicate predicate)`
`<S> MutableSortedBag<S>`	`selectInstancesOf(Class<S> clazz)`
`MutableSortedSet<T>`	`selectUnique()`
`<P> MutableSortedBag<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)`
`MutableSortedBag<T>`	`take(int count)`
`MutableSortedBag<T>`	`takeWhile(Predicate<? super T> predicate)`
`MutableSortedBag<T>`	`tap(Procedure<? super T> procedure)`
`ImmutableSortedBag<T>`	`toImmutable()`
`MutableSortedMap<T,Integer>`	`toMapOfItemToCount()`
`MutableList<ObjectIntPair<T>>`	`topOccurrences(int count)`
`MutableSortedBag<T>`	`toReversed()`
`MutableStack<T>`	`toStack()`
`String`	`toStringOfItemToCount()`
`MutableSortedBag<T>`	`with(T element)`
`MutableSortedBag<T>`	`withAll(Iterable<? extends T> elements)`
`MutableSortedBag<T>`	`without(T element)`
`MutableSortedBag<T>`	`withoutAll(Iterable<? extends T> elements)`
`<S> MutableList<Pair<T,S>>`	`zip(Iterable<S> that)`
`<S,R extends Collection<Pair<T,S>>> R`	`zip(Iterable<S> that, R target)`
`MutableSortedSet<Pair<T,Integer>>`	`zipWithIndex()`
`<R extends Collection<Pair<T,Integer>>> R`	`zipWithIndex(R target)`

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

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

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.bag.sorted.MutableSortedBag
countBy, countByEach, countByWith, flatCollectWith, selectDuplicates, toImmutableSortedBag

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable
forEachWithIndex, getFirst, getFirstOptional, getLast, getLastOptional, rejectWithIndex, selectWithIndex

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, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, into, isEmpty, makeString, makeString, makeString, makeString, max, maxBy, maxByOptional, maxOptional, maxOptional, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, 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

Methods inherited from interface org.eclipse.collections.api.bag.sorted.SortedBag
max, min

- Method Detail
  - of
```
public static <E,S extends MutableSortedBag<E>> UnmodifiableSortedBag<E> of(S bag)
```
    This method will take a MutableSortedBag and wrap it directly in a UnmodifiableSortedBag.
  - asUnmodifiable
```
public MutableSortedBag<T> asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableCollection<T>
    
    Specified by:
    
    asUnmodifiable in interface MutableSortedBag<T>
    
    Overrides:
    
    asUnmodifiable in class AbstractUnmodifiableMutableCollection<T>
  - asSynchronized
```
public MutableSortedBag<T> asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableCollection<T>
    
    Specified by:
    
    asSynchronized in interface MutableSortedBag<T>
    
    Overrides:
    
    asSynchronized in class AbstractUnmodifiableMutableCollection<T>
  - toImmutable
```
public ImmutableSortedBag<T> toImmutable()
```
    Specified by:
    
    toImmutable in interface Bag<T>
    
    Specified by:
    
    toImmutable in interface MutableCollection<T>
    
    Specified by:
    
    toImmutable in interface SortedBag<T>
    
    Overrides:
    
    toImmutable in class AbstractUnmodifiableMutableCollection<T>
  - clone
```
public UnmodifiableSortedBag<T> clone()
```
    Specified by:
    
    clone in interface MutableSortedBag<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
  - newEmpty
```
public MutableSortedBag<T> newEmpty()
```
    Specified by:
    
    newEmpty in interface MutableCollection<T>
    
    Specified by:
    
    newEmpty in interface MutableSortedBag<T>
    
    Overrides:
    
    newEmpty 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>
  - tap
```
public MutableSortedBag<T> tap(Procedure<? super T> procedure)
```
    Specified by:
    
    tap in interface Bag<T>
    
    Specified by:
    
    tap in interface MutableBagIterable<T>
    
    Specified by:
    
    tap in interface MutableCollection<T>
    
    Specified by:
    
    tap in interface MutableSortedBag<T>
    
    Specified by:
    
    tap in interface OrderedIterable<T>
    
    Specified by:
    
    tap in interface ReversibleIterable<T>
    
    Specified by:
    
    tap in interface RichIterable<T>
    
    Specified by:
    
    tap in interface SortedBag<T>
    
    Specified by:
    
    tap in interface SortedIterable<T>
    
    Overrides:
    
    tap in class AbstractUnmodifiableMutableCollection<T>
  - select
```
public MutableSortedBag<T> select(Predicate<? super T> predicate)
```
    Specified by:
    
    select in interface Bag<T>
    
    Specified by:
    
    select in interface MutableBagIterable<T>
    
    Specified by:
    
    select in interface MutableCollection<T>
    
    Specified by:
    
    select in interface MutableSortedBag<T>
    
    Specified by:
    
    select in interface OrderedIterable<T>
    
    Specified by:
    
    select in interface ReversibleIterable<T>
    
    Specified by:
    
    select in interface RichIterable<T>
    
    Specified by:
    
    select in interface SortedBag<T>
    
    Specified by:
    
    select in interface SortedIterable<T>
    
    Overrides:
    
    select in class AbstractUnmodifiableMutableCollection<T>
  - selectWith
```
public <P> MutableSortedBag<T> selectWith(Predicate2<? super T,? super P> predicate,
                                          P parameter)
```
    Specified by:
    
    selectWith in interface Bag<T>
    
    Specified by:
    
    selectWith in interface MutableBagIterable<T>
    
    Specified by:
    
    selectWith in interface MutableCollection<T>
    
    Specified by:
    
    selectWith in interface MutableSortedBag<T>
    
    Specified by:
    
    selectWith in interface OrderedIterable<T>
    
    Specified by:
    
    selectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    selectWith in interface RichIterable<T>
    
    Specified by:
    
    selectWith in interface SortedBag<T>
    
    Specified by:
    
    selectWith in interface SortedIterable<T>
    
    Overrides:
    
    selectWith in class AbstractUnmodifiableMutableCollection<T>
  - reject
```
public MutableSortedBag<T> reject(Predicate<? super T> predicate)
```
    Specified by:
    
    reject in interface Bag<T>
    
    Specified by:
    
    reject in interface MutableBagIterable<T>
    
    Specified by:
    
    reject in interface MutableCollection<T>
    
    Specified by:
    
    reject in interface MutableSortedBag<T>
    
    Specified by:
    
    reject in interface OrderedIterable<T>
    
    Specified by:
    
    reject in interface ReversibleIterable<T>
    
    Specified by:
    
    reject in interface RichIterable<T>
    
    Specified by:
    
    reject in interface SortedBag<T>
    
    Specified by:
    
    reject in interface SortedIterable<T>
    
    Overrides:
    
    reject in class AbstractUnmodifiableMutableCollection<T>
  - rejectWith
```
public <P> MutableSortedBag<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                          P parameter)
```
    Specified by:
    
    rejectWith in interface Bag<T>
    
    Specified by:
    
    rejectWith in interface MutableBagIterable<T>
    
    Specified by:
    
    rejectWith in interface MutableCollection<T>
    
    Specified by:
    
    rejectWith in interface MutableSortedBag<T>
    
    Specified by:
    
    rejectWith in interface OrderedIterable<T>
    
    Specified by:
    
    rejectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    rejectWith in interface RichIterable<T>
    
    Specified by:
    
    rejectWith in interface SortedBag<T>
    
    Specified by:
    
    rejectWith in interface SortedIterable<T>
    
    Overrides:
    
    rejectWith in class AbstractUnmodifiableMutableCollection<T>
  - partition
```
public PartitionMutableSortedBag<T> partition(Predicate<? super T> predicate)
```
    Specified by:
    
    partition in interface Bag<T>
    
    Specified by:
    
    partition in interface MutableBagIterable<T>
    
    Specified by:
    
    partition in interface MutableCollection<T>
    
    Specified by:
    
    partition in interface MutableSortedBag<T>
    
    Specified by:
    
    partition in interface OrderedIterable<T>
    
    Specified by:
    
    partition in interface ReversibleIterable<T>
    
    Specified by:
    
    partition in interface RichIterable<T>
    
    Specified by:
    
    partition in interface SortedBag<T>
    
    Specified by:
    
    partition in interface SortedIterable<T>
    
    Overrides:
    
    partition in class AbstractUnmodifiableMutableCollection<T>
  - partitionWith
```
public <P> PartitionMutableSortedBag<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                      P parameter)
```
    Specified by:
    
    partitionWith in interface Bag<T>
    
    Specified by:
    
    partitionWith in interface MutableBagIterable<T>
    
    Specified by:
    
    partitionWith in interface MutableCollection<T>
    
    Specified by:
    
    partitionWith in interface MutableSortedBag<T>
    
    Specified by:
    
    partitionWith in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWith in interface ReversibleIterable<T>
    
    Specified by:
    
    partitionWith in interface RichIterable<T>
    
    Specified by:
    
    partitionWith in interface SortedBag<T>
    
    Overrides:
    
    partitionWith in class AbstractUnmodifiableMutableCollection<T>
  - partitionWhile
```
public PartitionMutableSortedBag<T> partitionWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    partitionWhile in interface MutableSortedBag<T>
    
    Specified by:
    
    partitionWhile in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWhile in interface ReversibleIterable<T>
    
    Specified by:
    
    partitionWhile in interface SortedBag<T>
    
    Specified by:
    
    partitionWhile in interface SortedIterable<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> procedure)
```
    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> MutableList<V> collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function)
```
    Specified by:
    
    collectWithOccurrences in interface Bag<T>
    
    Specified by:
    
    collectWithOccurrences in interface MutableBagIterable<T>
    
    Specified by:
    
    collectWithOccurrences in interface MutableSortedBag<T>
    
    Specified by:
    
    collectWithOccurrences in interface SortedBag<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 MutableSortedMap<T,Integer> toMapOfItemToCount()
```
    Specified by:
    
    toMapOfItemToCount in interface Bag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface MutableBagIterable<T>
    
    Specified by:
    
    toMapOfItemToCount in interface MutableSortedBag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface SortedBag<T>
  - toStringOfItemToCount
```
public String toStringOfItemToCount()
```
    Specified by:
    
    toStringOfItemToCount in interface Bag<T>
  - selectByOccurrences
```
public MutableSortedBag<T> selectByOccurrences(IntPredicate predicate)
```
    Specified by:
    
    selectByOccurrences in interface Bag<T>
    
    Specified by:
    
    selectByOccurrences in interface MutableBagIterable<T>
    
    Specified by:
    
    selectByOccurrences in interface MutableSortedBag<T>
    
    Specified by:
    
    selectByOccurrences in interface SortedBag<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>
  - selectInstancesOf
```
public <S> MutableSortedBag<S> selectInstancesOf(Class<S> clazz)
```
    Specified by:
    
    selectInstancesOf in interface Bag<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableBagIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableCollection<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableSortedBag<T>
    
    Specified by:
    
    selectInstancesOf in interface OrderedIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface ReversibleIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface SortedBag<T>
    
    Specified by:
    
    selectInstancesOf in interface SortedIterable<T>
    
    Overrides:
    
    selectInstancesOf in class AbstractUnmodifiableMutableCollection<T>
  - collect
```
public <V> MutableList<V> collect(Function<? super T,? extends V> function)
```
    Specified by:
    
    collect in interface MutableCollection<T>
    
    Specified by:
    
    collect in interface MutableSortedBag<T>
    
    Specified by:
    
    collect in interface OrderedIterable<T>
    
    Specified by:
    
    collect in interface ReversibleIterable<T>
    
    Specified by:
    
    collect in interface RichIterable<T>
    
    Specified by:
    
    collect in interface SortedBag<T>
    
    Overrides:
    
    collect in class AbstractUnmodifiableMutableCollection<T>
  - collectWithIndex
```
public <V> MutableList<V> collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)
```
    Specified by:
    
    collectWithIndex in interface MutableSortedBag<T>
    
    Specified by:
    
    collectWithIndex in interface OrderedIterable<T>
    
    Specified by:
    
    collectWithIndex in interface ReversibleIterable<T>
    
    Specified by:
    
    collectWithIndex in interface SortedBag<T>
    
    Since:
    
    9.1.
  - collectWithIndex
```
public <V,R extends Collection<V>> R collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function,
                                                            R target)
```
    Specified by:
    
    collectWithIndex in interface OrderedIterable<T>
    
    Since:
    
    9.1.
  - collectBoolean
```
public MutableBooleanList collectBoolean(BooleanFunction<? super T> booleanFunction)
```
    Specified by:
    
    collectBoolean in interface MutableCollection<T>
    
    Specified by:
    
    collectBoolean in interface MutableSortedBag<T>
    
    Specified by:
    
    collectBoolean in interface OrderedIterable<T>
    
    Specified by:
    
    collectBoolean in interface ReversibleIterable<T>
    
    Specified by:
    
    collectBoolean in interface RichIterable<T>
    
    Specified by:
    
    collectBoolean in interface SortedBag<T>
    
    Overrides:
    
    collectBoolean in class AbstractUnmodifiableMutableCollection<T>
  - collectByte
```
public MutableByteList collectByte(ByteFunction<? super T> byteFunction)
```
    Specified by:
    
    collectByte in interface MutableCollection<T>
    
    Specified by:
    
    collectByte in interface MutableSortedBag<T>
    
    Specified by:
    
    collectByte in interface OrderedIterable<T>
    
    Specified by:
    
    collectByte in interface ReversibleIterable<T>
    
    Specified by:
    
    collectByte in interface RichIterable<T>
    
    Specified by:
    
    collectByte in interface SortedBag<T>
    
    Overrides:
    
    collectByte in class AbstractUnmodifiableMutableCollection<T>
  - collectChar
```
public MutableCharList collectChar(CharFunction<? super T> charFunction)
```
    Specified by:
    
    collectChar in interface MutableCollection<T>
    
    Specified by:
    
    collectChar in interface MutableSortedBag<T>
    
    Specified by:
    
    collectChar in interface OrderedIterable<T>
    
    Specified by:
    
    collectChar in interface ReversibleIterable<T>
    
    Specified by:
    
    collectChar in interface RichIterable<T>
    
    Specified by:
    
    collectChar in interface SortedBag<T>
    
    Overrides:
    
    collectChar in class AbstractUnmodifiableMutableCollection<T>
  - collectDouble
```
public MutableDoubleList collectDouble(DoubleFunction<? super T> doubleFunction)
```
    Specified by:
    
    collectDouble in interface MutableCollection<T>
    
    Specified by:
    
    collectDouble in interface MutableSortedBag<T>
    
    Specified by:
    
    collectDouble in interface OrderedIterable<T>
    
    Specified by:
    
    collectDouble in interface ReversibleIterable<T>
    
    Specified by:
    
    collectDouble in interface RichIterable<T>
    
    Specified by:
    
    collectDouble in interface SortedBag<T>
    
    Overrides:
    
    collectDouble in class AbstractUnmodifiableMutableCollection<T>
  - collectFloat
```
public MutableFloatList collectFloat(FloatFunction<? super T> floatFunction)
```
    Specified by:
    
    collectFloat in interface MutableCollection<T>
    
    Specified by:
    
    collectFloat in interface MutableSortedBag<T>
    
    Specified by:
    
    collectFloat in interface OrderedIterable<T>
    
    Specified by:
    
    collectFloat in interface ReversibleIterable<T>
    
    Specified by:
    
    collectFloat in interface RichIterable<T>
    
    Specified by:
    
    collectFloat in interface SortedBag<T>
    
    Overrides:
    
    collectFloat in class AbstractUnmodifiableMutableCollection<T>
  - collectInt
```
public MutableIntList collectInt(IntFunction<? super T> intFunction)
```
    Specified by:
    
    collectInt in interface MutableCollection<T>
    
    Specified by:
    
    collectInt in interface MutableSortedBag<T>
    
    Specified by:
    
    collectInt in interface OrderedIterable<T>
    
    Specified by:
    
    collectInt in interface ReversibleIterable<T>
    
    Specified by:
    
    collectInt in interface RichIterable<T>
    
    Specified by:
    
    collectInt in interface SortedBag<T>
    
    Overrides:
    
    collectInt in class AbstractUnmodifiableMutableCollection<T>
  - collectLong
```
public MutableLongList collectLong(LongFunction<? super T> longFunction)
```
    Specified by:
    
    collectLong in interface MutableCollection<T>
    
    Specified by:
    
    collectLong in interface MutableSortedBag<T>
    
    Specified by:
    
    collectLong in interface OrderedIterable<T>
    
    Specified by:
    
    collectLong in interface ReversibleIterable<T>
    
    Specified by:
    
    collectLong in interface RichIterable<T>
    
    Specified by:
    
    collectLong in interface SortedBag<T>
    
    Overrides:
    
    collectLong in class AbstractUnmodifiableMutableCollection<T>
  - collectShort
```
public MutableShortList collectShort(ShortFunction<? super T> shortFunction)
```
    Specified by:
    
    collectShort in interface MutableCollection<T>
    
    Specified by:
    
    collectShort in interface MutableSortedBag<T>
    
    Specified by:
    
    collectShort in interface OrderedIterable<T>
    
    Specified by:
    
    collectShort in interface ReversibleIterable<T>
    
    Specified by:
    
    collectShort in interface RichIterable<T>
    
    Specified by:
    
    collectShort in interface SortedBag<T>
    
    Overrides:
    
    collectShort in class AbstractUnmodifiableMutableCollection<T>
  - flatCollect
```
public <V> MutableList<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    flatCollect in interface MutableCollection<T>
    
    Specified by:
    
    flatCollect in interface MutableSortedBag<T>
    
    Specified by:
    
    flatCollect in interface OrderedIterable<T>
    
    Specified by:
    
    flatCollect in interface ReversibleIterable<T>
    
    Specified by:
    
    flatCollect in interface RichIterable<T>
    
    Specified by:
    
    flatCollect in interface SortedBag<T>
    
    Overrides:
    
    flatCollect in class AbstractUnmodifiableMutableCollection<T>
  - distinct
```
public MutableSortedSet<T> distinct()
```
    Specified by:
    
    distinct in interface MutableSortedBag<T>
    
    Specified by:
    
    distinct in interface OrderedIterable<T>
    
    Specified by:
    
    distinct in interface ReversibleIterable<T>
    
    Specified by:
    
    distinct in interface SortedBag<T>
    
    Specified by:
    
    distinct in interface SortedIterable<T>
  - corresponds
```
public <S> boolean corresponds(OrderedIterable<S> other,
                               Predicate2<? super T,? super S> predicate)
```
    Specified by:
    
    corresponds in interface OrderedIterable<T>
  - forEach
```
public void forEach(int startIndex,
                    int endIndex,
                    Procedure<? super T> procedure)
```
    Specified by:
    
    forEach in interface OrderedIterable<T>
  - forEachWithIndex
```
public void forEachWithIndex(int fromIndex,
                             int toIndex,
                             ObjectIntProcedure<? super T> objectIntProcedure)
```
    Specified by:
    
    forEachWithIndex in interface OrderedIterable<T>
  - toStack
```
public MutableStack<T> toStack()
```
    Specified by:
    
    toStack in interface OrderedIterable<T>
  - indexOf
```
public int indexOf(Object object)
```
    Specified by:
    
    indexOf in interface OrderedIterable<T>
  - takeWhile
```
public MutableSortedBag<T> takeWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    takeWhile in interface MutableSortedBag<T>
    
    Specified by:
    
    takeWhile in interface OrderedIterable<T>
    
    Specified by:
    
    takeWhile in interface ReversibleIterable<T>
    
    Specified by:
    
    takeWhile in interface SortedBag<T>
    
    Specified by:
    
    takeWhile in interface SortedIterable<T>
  - dropWhile
```
public MutableSortedBag<T> dropWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    dropWhile in interface MutableSortedBag<T>
    
    Specified by:
    
    dropWhile in interface OrderedIterable<T>
    
    Specified by:
    
    dropWhile in interface ReversibleIterable<T>
    
    Specified by:
    
    dropWhile in interface SortedBag<T>
    
    Specified by:
    
    dropWhile in interface SortedIterable<T>
  - collectWith
```
public <P,A> MutableList<A> collectWith(Function2<? super T,? super P,? extends A> function,
                                              P parameter)
```
    Specified by:
    
    collectWith in interface MutableCollection<T>
    
    Specified by:
    
    collectWith in interface MutableSortedBag<T>
    
    Specified by:
    
    collectWith in interface OrderedIterable<T>
    
    Specified by:
    
    collectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    collectWith in interface RichIterable<T>
    
    Specified by:
    
    collectWith in interface SortedBag<T>
    
    Overrides:
    
    collectWith in class AbstractUnmodifiableMutableCollection<T>
  - collectIf
```
public <V> MutableList<V> collectIf(Predicate<? super T> predicate,
                                    Function<? super T,? extends V> function)
```
    Specified by:
    
    collectIf in interface MutableCollection<T>
    
    Specified by:
    
    collectIf in interface MutableSortedBag<T>
    
    Specified by:
    
    collectIf in interface OrderedIterable<T>
    
    Specified by:
    
    collectIf in interface ReversibleIterable<T>
    
    Specified by:
    
    collectIf in interface RichIterable<T>
    
    Specified by:
    
    collectIf in interface SortedBag<T>
    
    Overrides:
    
    collectIf in class AbstractUnmodifiableMutableCollection<T>
  - detectIndex
```
public int detectIndex(Predicate<? super T> predicate)
```
    Specified by:
    
    detectIndex in interface OrderedIterable<T>
  - groupBy
```
public <V> MutableSortedBagMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
    Specified by:
    
    groupBy in interface Bag<T>
    
    Specified by:
    
    groupBy in interface MutableBagIterable<T>
    
    Specified by:
    
    groupBy in interface MutableCollection<T>
    
    Specified by:
    
    groupBy in interface MutableSortedBag<T>
    
    Specified by:
    
    groupBy in interface OrderedIterable<T>
    
    Specified by:
    
    groupBy in interface ReversibleIterable<T>
    
    Specified by:
    
    groupBy in interface RichIterable<T>
    
    Specified by:
    
    groupBy in interface SortedBag<T>
    
    Specified by:
    
    groupBy in interface SortedIterable<T>
    
    Overrides:
    
    groupBy in class AbstractUnmodifiableMutableCollection<T>
  - groupByEach
```
public <V> MutableSortedBagMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    groupByEach in interface Bag<T>
    
    Specified by:
    
    groupByEach in interface MutableBagIterable<T>
    
    Specified by:
    
    groupByEach in interface MutableCollection<T>
    
    Specified by:
    
    groupByEach in interface MutableSortedBag<T>
    
    Specified by:
    
    groupByEach in interface OrderedIterable<T>
    
    Specified by:
    
    groupByEach in interface ReversibleIterable<T>
    
    Specified by:
    
    groupByEach in interface RichIterable<T>
    
    Specified by:
    
    groupByEach in interface SortedBag<T>
    
    Specified by:
    
    groupByEach in interface SortedIterable<T>
    
    Overrides:
    
    groupByEach in class AbstractUnmodifiableMutableCollection<T>
  - zip
```
public <S> MutableList<Pair<T,S>> zip(Iterable<S> that)
```
    Specified by:
    
    zip in interface MutableCollection<T>
    
    Specified by:
    
    zip in interface MutableSortedBag<T>
    
    Specified by:
    
    zip in interface OrderedIterable<T>
    
    Specified by:
    
    zip in interface ReversibleIterable<T>
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Specified by:
    
    zip in interface SortedIterable<T>
    
    Overrides:
    
    zip in class AbstractUnmodifiableMutableCollection<T>
  - zip
```
public <S,R extends Collection<Pair<T,S>>> R zip(Iterable<S> that,
                                                             R target)
```
    Specified by:
    
    zip in interface OrderedIterable<T>
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Overrides:
    
    zip in class AbstractUnmodifiableMutableCollection<T>
  - zipWithIndex
```
public MutableSortedSet<Pair<T,Integer>> zipWithIndex()
```
    Specified by:
    
    zipWithIndex in interface Bag<T>
    
    Specified by:
    
    zipWithIndex in interface MutableBagIterable<T>
    
    Specified by:
    
    zipWithIndex in interface MutableCollection<T>
    
    Specified by:
    
    zipWithIndex in interface MutableSortedBag<T>
    
    Specified by:
    
    zipWithIndex in interface OrderedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface ReversibleIterable<T>
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Specified by:
    
    zipWithIndex in interface SortedBag<T>
    
    Specified by:
    
    zipWithIndex in interface SortedIterable<T>
    
    Overrides:
    
    zipWithIndex in class AbstractUnmodifiableMutableCollection<T>
  - zipWithIndex
```
public <R extends Collection<Pair<T,Integer>>> R zipWithIndex(R target)
```
    Specified by:
    
    zipWithIndex in interface OrderedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Overrides:
    
    zipWithIndex in class AbstractUnmodifiableMutableCollection<T>
  - toReversed
```
public MutableSortedBag<T> toReversed()
```
    Specified by:
    
    toReversed in interface MutableSortedBag<T>
    
    Specified by:
    
    toReversed in interface ReversibleIterable<T>
    
    Specified by:
    
    toReversed in interface SortedBag<T>
  - take
```
public MutableSortedBag<T> take(int count)
```
    Specified by:
    
    take in interface MutableSortedBag<T>
    
    Specified by:
    
    take in interface ReversibleIterable<T>
    
    Specified by:
    
    take in interface SortedBag<T>
  - drop
```
public MutableSortedBag<T> drop(int count)
```
    Specified by:
    
    drop in interface MutableSortedBag<T>
    
    Specified by:
    
    drop in interface ReversibleIterable<T>
    
    Specified by:
    
    drop in interface SortedBag<T>
  - reverseForEach
```
public void reverseForEach(Procedure<? super T> procedure)
```
    Specified by:
    
    reverseForEach in interface ReversibleIterable<T>
  - reverseForEachWithIndex
```
public void reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure)
```
    Specified by:
    
    reverseForEachWithIndex in interface ReversibleIterable<T>
  - asReversed
```
public LazyIterable<T> asReversed()
```
    Specified by:
    
    asReversed in interface ReversibleIterable<T>
  - detectLastIndex
```
public int detectLastIndex(Predicate<? super T> predicate)
```
    Specified by:
    
    detectLastIndex in interface ReversibleIterable<T>
  - comparator
```
public Comparator<? super T> comparator()
```
    Specified by:
    
    comparator in interface SortedBag<T>
    
    Specified by:
    
    comparator in interface SortedIterable<T>
  - with
```
public MutableSortedBag<T> with(T element)
```
    Specified by:
    
    with in interface MutableBagIterable<T>
    
    Specified by:
    
    with in interface MutableCollection<T>
    
    Specified by:
    
    with in interface MutableSortedBag<T>
    
    Overrides:
    
    with in class AbstractUnmodifiableMutableCollection<T>
  - without
```
public MutableSortedBag<T> without(T element)
```
    Specified by:
    
    without in interface MutableBagIterable<T>
    
    Specified by:
    
    without in interface MutableCollection<T>
    
    Specified by:
    
    without in interface MutableSortedBag<T>
    
    Overrides:
    
    without in class AbstractUnmodifiableMutableCollection<T>
  - withAll
```
public MutableSortedBag<T> withAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withAll in interface MutableBagIterable<T>
    
    Specified by:
    
    withAll in interface MutableCollection<T>
    
    Specified by:
    
    withAll in interface MutableSortedBag<T>
    
    Overrides:
    
    withAll in class AbstractUnmodifiableMutableCollection<T>
  - withoutAll
```
public MutableSortedBag<T> withoutAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withoutAll in interface MutableBagIterable<T>
    
    Specified by:
    
    withoutAll in interface MutableCollection<T>
    
    Specified by:
    
    withoutAll in interface MutableSortedBag<T>
    
    Overrides:
    
    withoutAll in class AbstractUnmodifiableMutableCollection<T>
  - compareTo
```
public int compareTo(SortedBag<T> o)
```
    Specified by:
    
    compareTo in interface Comparable<T>
  - selectUnique
```
public MutableSortedSet<T> selectUnique()
```
    Specified by:
    
    selectUnique in interface Bag<T>
    
    Specified by:
    
    selectUnique in interface MutableBagIterable<T>
    
    Specified by:
    
    selectUnique in interface MutableSortedBag<T>
    
    Specified by:
    
    selectUnique in interface SortedBag<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 UnmodifiableSortedBag<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.collection.MutableCollection

Methods inherited from interface org.eclipse.collections.api.bag.sorted.MutableSortedBag

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable

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

Methods inherited from interface org.eclipse.collections.api.bag.sorted.SortedBag

Method Detail

of

asUnmodifiable

asSynchronized

toImmutable

clone

equals

hashCode

newEmpty

addOccurrences

removeOccurrences

setOccurrences

tap

select

selectWith

reject

rejectWith

partition

partitionWith

partitionWhile

sizeDistinct

occurrencesOf

forEachWithOccurrences

anySatisfyWithOccurrences

allSatisfyWithOccurrences

noneSatisfyWithOccurrences

detectWithOccurrences

collectWithOccurrences

collectWithOccurrences

toMapOfItemToCount

toStringOfItemToCount

selectByOccurrences

topOccurrences

bottomOccurrences

selectInstancesOf

collect

collectWithIndex

collectWithIndex

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

flatCollect

distinct

corresponds

forEach

forEachWithIndex

toStack

indexOf

takeWhile

dropWhile

collectWith

collectIf

detectIndex

groupBy

groupByEach

zip

zip

zipWithIndex

zipWithIndex

toReversed

take

drop

reverseForEach