SynchronizedSortedBag (Goldman Sachs Collections

java.lang.Object
- com.gs.collections.impl.collection.AbstractSynchronizedRichIterable<T>
- - com.gs.collections.impl.collection.mutable.AbstractSynchronizedMutableCollection<T>
  - - com.gs.collections.impl.bag.sorted.mutable.SynchronizedSortedBag<T>

All Implemented Interfaces:

com.gs.collections.api.bag.Bag<T>, com.gs.collections.api.bag.MutableBagIterable<T>, com.gs.collections.api.bag.sorted.MutableSortedBag<T>, com.gs.collections.api.bag.sorted.SortedBag<T>, com.gs.collections.api.collection.MutableCollection<T>, com.gs.collections.api.InternalIterable<T>, com.gs.collections.api.ordered.OrderedIterable<T>, com.gs.collections.api.ordered.ReversibleIterable<T>, com.gs.collections.api.ordered.SortedIterable<T>, com.gs.collections.api.RichIterable<T>, java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<com.gs.collections.api.bag.sorted.SortedBag<T>>, java.lang.Iterable<T>, java.util.Collection<T>
```
@ThreadSafe
public class SynchronizedSortedBag<T>
extends AbstractSynchronizedMutableCollection<T>
implements com.gs.collections.api.bag.sorted.MutableSortedBag<T>, java.io.Serializable
```
A synchronized view of a MutableSortedBag. It is imperative that the user manually synchronize on the collection when iterating over it using the standard JDK iterator or JDK 5 for loop, as per Collections.synchronizedCollection(Collection).

See Also:
MutableSortedBag.asSynchronized(), Serialized Form

Field Summary
- Fields inherited from class com.gs.collections.impl.collection.AbstractSynchronizedRichIterable
  delegate, lock

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addOccurrences(T item, int occurrences)`
`com.gs.collections.api.bag.ParallelBag<T>`	`asParallel(java.util.concurrent.ExecutorService executorService, int batchSize)`
`com.gs.collections.api.LazyIterable<T>`	`asReversed()` Returns a reversed view of this ReversibleIterable.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`asSynchronized()` Returns a synchronized (thread-safe) collection backed by this collection.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`asUnmodifiable()` Returns an unmodifiable view of the set.
`com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>>`	`bottomOccurrences(int count)` Returns the `count` least frequently occurring items.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`clone()`
`<V> com.gs.collections.api.list.MutableList<V>`	`collect(com.gs.collections.api.block.function.Function<? super T,? extends V> function)` Returns a new collection with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableBooleanList`	`collectBoolean(com.gs.collections.api.block.function.primitive.BooleanFunction<? super T> booleanFunction)` Returns a new primitive `boolean` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableByteList`	`collectByte(com.gs.collections.api.block.function.primitive.ByteFunction<? super T> byteFunction)` Returns a new primitive `byte` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableCharList`	`collectChar(com.gs.collections.api.block.function.primitive.CharFunction<? super T> charFunction)` Returns a new primitive `char` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableDoubleList`	`collectDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> doubleFunction)` Returns a new primitive `double` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableFloatList`	`collectFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> floatFunction)` Returns a new primitive `float` iterable with the results of applying the specified function on each element of the source collection.
`<V> com.gs.collections.api.list.MutableList<V>`	`collectIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate, com.gs.collections.api.block.function.Function<? super T,? extends V> function)` Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate.
`com.gs.collections.api.list.primitive.MutableIntList`	`collectInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> intFunction)` Returns a new primitive `int` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableLongList`	`collectLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> longFunction)` Returns a new primitive `long` iterable with the results of applying the specified function on each element of the source collection.
`com.gs.collections.api.list.primitive.MutableShortList`	`collectShort(com.gs.collections.api.block.function.primitive.ShortFunction<? super T> shortFunction)` Returns a new primitive `short` iterable with the results of applying the specified function on each element of the source collection.
`<P,V> com.gs.collections.api.list.MutableList<V>`	`collectWith(com.gs.collections.api.block.function.Function2<? super T,? super P,? extends V> function, P parameter)` Same as `RichIterable.collect(Function)` with a `Function2` and specified parameter which is passed to the block.
`java.util.Comparator<? super T>`	`comparator()` Returns the comparator used to order the elements in this bag, or null if this bag uses the natural ordering of its elements.
`int`	`compareTo(com.gs.collections.api.bag.sorted.SortedBag<T> o)`
`<S> boolean`	`corresponds(com.gs.collections.api.ordered.OrderedIterable<S> other, com.gs.collections.api.block.predicate.Predicate2<? super T,? super S> predicate)` Returns true if both OrderedIterables have the same length and `predicate` returns true for all corresponding elements e1 of this `OrderedIterable` and e2 of `other`.
`int`	`detectIndex(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns the index of the first element of the `OrderedIterable` for which the `predicate` evaluates to true.
`int`	`detectLastIndex(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns the index of the last element of the `ReversibleIterable` for which the `predicate` evaluates to true.
`com.gs.collections.api.set.sorted.MutableSortedSet<T>`	`distinct()` Returns a new `SortedIterable` containing the distinct elements in this iterable.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`drop(int count)` Returns an iterable after skipping the first `count` elements or an empty iterable if the `count` is greater than the length of the iterable.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`dropWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns the final elements that do not satisfy the Predicate.
`<V> com.gs.collections.api.list.MutableList<V>`	`flatCollect(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)` `flatCollect` is a special case of `RichIterable.collect(Function)`.
`void`	`forEach(int startIndex, int endIndex, com.gs.collections.api.block.procedure.Procedure<? super T> procedure)` Iterates over the section of the iterable covered by the specified inclusive indexes.
`void`	`forEachWithIndex(int fromIndex, int toIndex, com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)` Iterates over the section of the iterable covered by the specified inclusive indexes.
`void`	`forEachWithOccurrences(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> procedure)` For each distinct item, with the number of occurrences, execute the specified procedure.
`protected com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`getDelegate()`
`<V> com.gs.collections.api.multimap.sortedbag.MutableSortedBagMultimap<V,T>`	`groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function)` For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.
`<V> com.gs.collections.api.multimap.sortedbag.MutableSortedBagMultimap<V,T>`	`groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)` Similar to `RichIterable.groupBy(Function)`, except the result of evaluating function will return a collection of keys for each value.
`int`	`indexOf(java.lang.Object object)` Returns the index of the first occurrence of the specified item in this iterable, or -1 if this iterable does not contain the item.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`newEmpty()` Creates a new empty mutable version of the same collection type.
`int`	`occurrencesOf(java.lang.Object item)` The occurrences of a distinct item in the bag.
`static <E> SynchronizedSortedBag<E>`	`of(com.gs.collections.api.bag.sorted.MutableSortedBag<E> bag)`
`static <E> com.gs.collections.api.bag.sorted.MutableSortedBag<E>`	`of(com.gs.collections.api.bag.sorted.MutableSortedBag<E> bag, java.lang.Object lock)`
`com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T>`	`partition(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
`com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T>`	`partitionWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
`<P> com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T>`	`partitionWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter)` Filters a collection into a PartitionIterable based on the evaluation of the predicate.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`reject(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns all elements of the source collection that return false when evaluating of the predicate.
`<P> com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`rejectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.reject(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`boolean`	`removeOccurrences(java.lang.Object item, int occurrences)`
`void`	`reverseForEach(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)` Evaluates the procedure for each element of the list iterating in reverse order.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`select(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns all elements of the source collection that return true when evaluating the predicate.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`selectByOccurrences(com.gs.collections.api.block.predicate.primitive.IntPredicate predicate)` Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
`<S> com.gs.collections.api.bag.sorted.MutableSortedBag<S>`	`selectInstancesOf(java.lang.Class<S> clazz)` Returns all elements of the source collection that are instances of the Class `clazz`.
`<P> com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`selectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.select(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`boolean`	`setOccurrences(T item, int occurrences)`
`int`	`sizeDistinct()` The size of the Bag when counting only distinct elements.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`take(int count)` Returns the first `count` elements of the iterable or all the elements in the iterable if `count` is greater than the length of the iterable.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`takeWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)` Returns the initial elements that satisfy the Predicate.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`tap(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)` Executes the Procedure for each element in the iterable and returns `this`.
`com.gs.collections.api.bag.sorted.ImmutableSortedBag<T>`	`toImmutable()` Convert the SortedBag to an ImmutableSortedBag.
`com.gs.collections.api.map.sorted.MutableSortedMap<T,java.lang.Integer>`	`toMapOfItemToCount()` Converts the Bag to a Map of the Item type to its count as an Integer.
`com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>>`	`topOccurrences(int count)` Returns the `count` most frequently occurring items.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`toReversed()` Returns a new ReversibleIterable in reverse order.
`com.gs.collections.api.stack.MutableStack<T>`	`toStack()` Converts the SortedIterable to a mutable MutableStack implementation.
`java.lang.String`	`toStringOfItemToCount()` Returns a string representation of this bag.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`with(T element)` This method allows mutable and fixed size collections the ability to add elements to their existing elements.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`withAll(java.lang.Iterable<? extends T> elements)` This method allows mutable and fixed size collections the ability to add multiple elements to their existing elements.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`without(T element)` This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
`com.gs.collections.api.bag.sorted.MutableSortedBag<T>`	`withoutAll(java.lang.Iterable<? extends T> elements)` This method allows mutable and fixed size collections the ability to remove multiple elements from their existing elements.
`protected java.lang.Object`	`writeReplace()`
`<S> com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.Pair<T,S>>`	`zip(java.lang.Iterable<S> that)` Returns a `RichIterable` formed from this `RichIterable` and another `RichIterable` by combining corresponding elements in pairs.
`com.gs.collections.api.set.sorted.MutableSortedSet<com.gs.collections.api.tuple.Pair<T,java.lang.Integer>>`	`zipWithIndex()` Zips this `RichIterable` with its indices.

Methods inherited from class com.gs.collections.impl.collection.mutable.AbstractSynchronizedMutableCollection
add, addAll, addAllIterable, aggregateBy, aggregateInPlaceBy, clear, injectIntoWith, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterable, selectAndRejectWith

Methods inherited from class com.gs.collections.impl.collection.AbstractSynchronizedRichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, equals, flatCollect, forEach, forEachWith, forEachWithIndex, getFirst, getLast, getLock, groupBy, groupByEach, groupByUniqueKey, groupByUniqueKey, hashCode, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, iterator, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

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

Methods inherited from interface com.gs.collections.api.bag.sorted.MutableSortedBag
aggregateBy, aggregateInPlaceBy

Methods inherited from interface com.gs.collections.api.bag.sorted.SortedBag
max, min

Methods inherited from interface com.gs.collections.api.ordered.OrderedIterable
forEachWithIndex, getFirst, getLast, zip, zipWithIndex

Methods inherited from interface com.gs.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, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, groupBy, groupByEach, groupByUniqueKey, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, maxBy, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString

Methods inherited from interface com.gs.collections.api.InternalIterable
forEach, forEachWith

Methods inherited from interface java.lang.Iterable
iterator

Methods inherited from interface com.gs.collections.api.bag.Bag
equals, hashCode

Methods inherited from interface com.gs.collections.api.collection.MutableCollection
addAllIterable, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith

Methods inherited from interface java.util.Collection
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

- Method Detail
  - of
```
public static <E> SynchronizedSortedBag<E> of(com.gs.collections.api.bag.sorted.MutableSortedBag<E> bag)
```
  - of
```
public static <E> com.gs.collections.api.bag.sorted.MutableSortedBag<E> of(com.gs.collections.api.bag.sorted.MutableSortedBag<E> bag,
                                                           java.lang.Object lock)
```
  - getDelegate
```
protected com.gs.collections.api.bag.sorted.MutableSortedBag<T> getDelegate()
```
    Overrides:
    
    getDelegate in class AbstractSynchronizedMutableCollection<T>
  - with
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> with(T element)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to add elements to their existing elements. In order to support fixed size a new instance of a collection would have to be returned taking the elements of the original collection and appending the new element to form the new collection. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.with("1");
 list = list.with("2");
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by with, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling add on itself.
    Specified by:
    
    with in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    with in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    with in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.add(Object)
  - without
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> without(T element)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to remove elements from their existing elements. In order to support fixed size a new instance of a collection would have to be returned contaning the elements that would be left from the original collection after calling remove. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.without("1");
 list = list.without("2");
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by without, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling remove on itself.
    Specified by:
    
    without in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    without in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    without in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.remove(Object)
  - withAll
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> withAll(java.lang.Iterable<? extends T> elements)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to add multiple elements to their existing elements. In order to support fixed size a new instance of a collection would have to be returned taking the elements of the original collection and appending the new elements to form the new collection. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.withAll(FastList.newListWith("1", "2"));
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by withAll, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling addAll on itself.
    Specified by:
    
    withAll in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    withAll in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    withAll in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.addAll(Collection)
  - withoutAll
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> withoutAll(java.lang.Iterable<? extends T> elements)
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    This method allows mutable and fixed size collections the ability to remove multiple elements from their existing elements. In order to support fixed size a new instance of a collection would have to be returned contaning the elements that would be left from the original collection after calling removeAll. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken:
```
 MutableCollection list;
 list = list.withoutAll(FastList.newListWith("1", "2"));
 return list;
 
```
    In the case of FixedSizeCollection a new instance of MutableCollection will be returned by withoutAll, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling removeAll on itself.
    Specified by:
    
    withoutAll in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    withoutAll in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    withoutAll in interface com.gs.collections.api.collection.MutableCollection<T>
    
    See Also:
    Collection.removeAll(Collection)
  - newEmpty
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> newEmpty()
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    
    Creates a new empty mutable version of the same collection type. For example, if this instance is a FastList, this method will return a new empty FastList. If the class of this instance is immutable or fixed size (i.e. SingletonList) then a mutable alternative to the class will be provided.
    
    Specified by:
    
    newEmpty in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    newEmpty in interface com.gs.collections.api.collection.MutableCollection<T>
  - clone
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> clone()
```
    Specified by:
    
    clone in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Overrides:
    
    clone in class java.lang.Object
  - comparator
```
public java.util.Comparator<? super T> comparator()
```
    Description copied from interface: com.gs.collections.api.bag.sorted.SortedBag
    
    Returns the comparator used to order the elements in this bag, or null if this bag uses the natural ordering of its elements.
    
    Specified by:
    
    comparator in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    comparator in interface com.gs.collections.api.ordered.SortedIterable<T>
  - compareTo
```
public int compareTo(com.gs.collections.api.bag.sorted.SortedBag<T> o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<com.gs.collections.api.bag.sorted.SortedBag<T>>
  - writeReplace
```
protected java.lang.Object writeReplace()
```
  - addOccurrences
```
public void addOccurrences(T item,
                  int occurrences)
```
    Specified by:
    
    addOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - removeOccurrences
```
public boolean removeOccurrences(java.lang.Object item,
                        int occurrences)
```
    Specified by:
    
    removeOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - setOccurrences
```
public boolean setOccurrences(T item,
                     int occurrences)
```
    Specified by:
    
    setOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - topOccurrences
```
public com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> topOccurrences(int count)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns the count most frequently occurring items. In the event of a tie, all of the items with the number of occurrences that match the occurrences of the last item will be returned.
    
    Specified by:
    
    topOccurrences in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    topOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - selectByOccurrences
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> selectByOccurrences(com.gs.collections.api.block.predicate.primitive.IntPredicate predicate)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    selectByOccurrences in interface com.gs.collections.api.bag.sorted.SortedBag<T>
  - bottomOccurrences
```
public com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> bottomOccurrences(int count)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns the count least frequently occurring items. In the event of a tie, all of the items with the number of occurrences that match the occurrences of the last item will be returned.
    
    Specified by:
    
    bottomOccurrences in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    bottomOccurrences in interface com.gs.collections.api.bag.MutableBagIterable<T>
  - toMapOfItemToCount
```
public com.gs.collections.api.map.sorted.MutableSortedMap<T,java.lang.Integer> toMapOfItemToCount()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Converts the Bag to a Map of the Item type to its count as an Integer.
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface com.gs.collections.api.bag.sorted.SortedBag<T>
  - forEachWithOccurrences
```
public void forEachWithOccurrences(com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> procedure)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    For each distinct item, with the number of occurrences, execute the specified procedure.
    
    Specified by:
    
    forEachWithOccurrences in interface com.gs.collections.api.bag.Bag<T>
  - occurrencesOf
```
public int occurrencesOf(java.lang.Object item)
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    The occurrences of a distinct item in the bag.
    
    Specified by:
    
    occurrencesOf in interface com.gs.collections.api.bag.Bag<T>
  - sizeDistinct
```
public int sizeDistinct()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    The size of the Bag when counting only distinct elements.
    
    Specified by:
    
    sizeDistinct in interface com.gs.collections.api.bag.Bag<T>
  - toStringOfItemToCount
```
public java.lang.String toStringOfItemToCount()
```
    Description copied from interface: com.gs.collections.api.bag.Bag
    
    Returns a string representation of this bag. The string representation consists of a list of element-count mappings. The elements each appear once, in an order consistent with other methods like Bag.forEachWithOccurrences(ObjectIntProcedure) and Iterable.iterator(). The element-count mappings are enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each element-count mapping is rendered as the element followed by an equals sign ("=") followed by the number of ooccurrences. Elements and are converted to strings as by String.valueOf(Object).
    The string representation is similar to AbstractMap.toString(), not RichIterable.toString().
    
    Specified by:
    
    toStringOfItemToCount in interface com.gs.collections.api.bag.Bag<T>
    
    Returns:
    a string representation of this bag
  - indexOf
```
public int indexOf(java.lang.Object object)
```
    Description copied from interface: com.gs.collections.api.ordered.OrderedIterable
    
    Returns the index of the first occurrence of the specified item in this iterable, or -1 if this iterable does not contain the item.
    
    Specified by:
    
    indexOf in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    See Also:
    List.indexOf(Object)
  - toStack
```
public com.gs.collections.api.stack.MutableStack<T> toStack()
```
    Description copied from interface: com.gs.collections.api.ordered.SortedIterable
    
    Converts the SortedIterable to a mutable MutableStack implementation.
    
    Specified by:
    
    toStack in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    toStack in interface com.gs.collections.api.ordered.SortedIterable<T>
  - partitionWhile
```
public com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T> partitionWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.SortedIterable
    
    Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements. Short circuits at the first element which does satisfy the Predicate.
    
    Specified by:
    
    partitionWhile in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    partitionWhile in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    partitionWhile in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    partitionWhile in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    partitionWhile in interface com.gs.collections.api.ordered.SortedIterable<T>
  - distinct
```
public com.gs.collections.api.set.sorted.MutableSortedSet<T> distinct()
```
    Description copied from interface: com.gs.collections.api.ordered.SortedIterable
    
    Returns a new SortedIterable containing the distinct elements in this iterable.
    Conceptually similar to RichIterable.toSet().RichIterable.toList() but retains the original order. If an element appears multiple times in this iterable, the first one will be copied into the result.
    
    Specified by:
    
    distinct in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    distinct in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    distinct in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    distinct in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    distinct in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Returns:
    SortedIterable of distinct elements
  - takeWhile
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> takeWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.SortedIterable
    
    Returns the initial elements that satisfy the Predicate. Short circuits at the first element which does not satisfy the Predicate.
    
    Specified by:
    
    takeWhile in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    takeWhile in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    takeWhile in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    takeWhile in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    takeWhile in interface com.gs.collections.api.ordered.SortedIterable<T>
  - dropWhile
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> dropWhile(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.SortedIterable
    
    Returns the final elements that do not satisfy the Predicate. Short circuits at the first element which does satisfy the Predicate.
    
    Specified by:
    
    dropWhile in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    dropWhile in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    dropWhile in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    dropWhile in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    dropWhile in interface com.gs.collections.api.ordered.SortedIterable<T>
  - corresponds
```
public <S> boolean corresponds(com.gs.collections.api.ordered.OrderedIterable<S> other,
                      com.gs.collections.api.block.predicate.Predicate2<? super T,? super S> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.OrderedIterable
    
    Returns true if both OrderedIterables have the same length and predicate returns true for all corresponding elements e1 of this OrderedIterable and e2 of other. The predicate is evaluated for each element at the same position of each OrderedIterable in a forward iteration order. This is a short circuit pattern.
    
    Specified by:
    
    corresponds in interface com.gs.collections.api.ordered.OrderedIterable<T>
  - forEach
```
public void forEach(int startIndex,
           int endIndex,
           com.gs.collections.api.block.procedure.Procedure<? super T> procedure)
```
    Description copied from interface: com.gs.collections.api.ordered.OrderedIterable
    Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
```
e.g.
 OrderedIterable people = FastList.newListWith(ted, mary, bob, sally)
 people.forEach(0, 1, new Procedure()
 {
     public void value(Person person)
     {
          LOGGER.info(person.getName());
     }
 });
 
```
    This code would output ted and mary's names.
    Specified by:
    
    forEach in interface com.gs.collections.api.ordered.OrderedIterable<T>
  - forEachWithIndex
```
public void forEachWithIndex(int fromIndex,
                    int toIndex,
                    com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure<? super T> objectIntProcedure)
```
    Description copied from interface: com.gs.collections.api.ordered.OrderedIterable
    Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
```
e.g.
 OrderedIterable people = FastList.newListWith(ted, mary, bob, sally)
 people.forEachWithIndex(0, 1, new ObjectIntProcedure()
 {
     public void value(Person person, int index)
     {
          LOGGER.info(person.getName());
     }
 });
 
```
    This code would output ted and mary's names.
    Specified by:
    
    forEachWithIndex in interface com.gs.collections.api.ordered.OrderedIterable<T>
  - detectIndex
```
public int detectIndex(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.OrderedIterable
    
    Returns the index of the first element of the OrderedIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
    
    Specified by:
    
    detectIndex in interface com.gs.collections.api.ordered.OrderedIterable<T>
  - tap
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> tap(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Executes the Procedure for each element in the iterable and returns this.
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> tapped =
     people.tap(person -> LOGGER.info(person.getName()));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> tapped =
     people.tap(new Procedure()
     {
         public void value(Person person)
         {
             LOGGER.info(person.getName());
         }
     });
 
```
    Specified by:
    
    tap in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    tap in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    tap in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    tap in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    tap in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    tap in interface com.gs.collections.api.RichIterable<T>
    
    See Also:
    RichIterable.each(Procedure), InternalIterable.forEach(Procedure)
  - select
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> select(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter.
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> selected =
     people.select(person -> person.getAddress().getCity().equals("London"));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> selected =
     people.select(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getCity().equals("London");
         }
     });
```
    Specified by:
    
    select in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    select in interface com.gs.collections.api.RichIterable<T>
  - selectWith
```
public <P> com.gs.collections.api.bag.sorted.MutableSortedBag<T> selectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                                                                   P parameter)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Similar to RichIterable.select(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
    E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> selected =
     people.selectWith((Person person, Integer age) -> person.getAge() >= age, Integer.valueOf(18));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> selected =
     people.selectWith(new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() >= age;
         }
     }, Integer.valueOf(18));
 
```
    Specified by:
    
    selectWith in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    selectWith in interface com.gs.collections.api.RichIterable<T>
    
    Parameters:
    predicate - a Predicate2 to use as the select criteria
    parameter - a parameter to pass in for evaluation of the second argument P in predicate
    See Also:
    RichIterable.select(Predicate)
  - reject
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> reject(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns all elements of the source collection that return false when evaluating of the predicate. This method is also sometimes called filterNot and is the equivalent of calling iterable.select(Predicates.not(predicate)).
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> rejected =
     people.reject(person -> person.person.getLastName().equals("Smith"));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> rejected =
     people.reject(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.person.getLastName().equals("Smith");
         }
     });
 
```
    Specified by:
    
    reject in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    reject in interface com.gs.collections.api.RichIterable<T>
    
    Parameters:
    predicate - a Predicate to use as the reject criteria
    
    Returns:
    a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false
  - rejectWith
```
public <P> com.gs.collections.api.bag.sorted.MutableSortedBag<T> rejectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                                                                   P parameter)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Similar to RichIterable.reject(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
    E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> rejected =
     people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18));
 
```
    Example using an anonymous inner class:
```
 MutableList<Person> rejected =
     people.rejectWith(new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() < age;
         }
     }, Integer.valueOf(18));
 
```
    Specified by:
    
    rejectWith in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    rejectWith in interface com.gs.collections.api.RichIterable<T>
    
    Parameters:
    predicate - a Predicate2 to use as the select criteria
    parameter - a parameter to pass in for evaluation of the second argument P in predicate
    See Also:
    RichIterable.select(Predicate)
  - partition
```
public com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T> partition(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
    Example using a Java 8 lambda expression:
```
 PartitionIterable<Person> newYorkersAndNonNewYorkers =
     people.partition(person -> person.getAddress().getState().getName().equals("New York"));
 
```
    Example using an anonymous inner class:
```
 PartitionIterable<Person> newYorkersAndNonNewYorkers =
     people.partition(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getState().getName().equals("New York");
         }
     });
 
```
    Specified by:
    
    partition in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    partition in interface com.gs.collections.api.RichIterable<T>
  - partitionWith
```
public <P> com.gs.collections.api.partition.bag.sorted.PartitionMutableSortedBag<T> partitionWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                                                                                         P parameter)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Filters a collection into a PartitionIterable based on the evaluation of the predicate.
    Example using a Java 8 lambda expression:
```
 PartitionIterable<Person>> newYorkersAndNonNewYorkers =
     people.partitionWith((Person person, String state) -> person.getAddress().getState().getName().equals(state), "New York");
 
```
    Example using an anonymous inner class:
```
 PartitionIterable<Person>> newYorkersAndNonNewYorkers =
     people.partitionWith(new Predicate2<Person, String>()
     {
         public boolean accept(Person person, String state)
         {
             return person.getAddress().getState().getName().equals(state);
         }
     }, "New York");
 
```
    Specified by:
    
    partitionWith in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    partitionWith in interface com.gs.collections.api.RichIterable<T>
  - collectBoolean
```
public com.gs.collections.api.list.primitive.MutableBooleanList collectBoolean(com.gs.collections.api.block.function.primitive.BooleanFunction<? super T> booleanFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive boolean iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 BooleanIterable licenses =
     people.collectBoolean(person -> person.hasDrivingLicense());
 
```
    Example using an anonymous inner class:
```
 BooleanIterable licenses =
     people.collectBoolean(new BooleanFunction<Person>()
     {
         public boolean booleanValueOf(Person person)
         {
             return person.hasDrivingLicense();
         }
     });
 
```
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectBoolean in interface com.gs.collections.api.RichIterable<T>
  - collectByte
```
public com.gs.collections.api.list.primitive.MutableByteList collectByte(com.gs.collections.api.block.function.primitive.ByteFunction<? super T> byteFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive byte iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 ByteIterable bytes =
     people.collectByte(person -> person.getCode());
 
```
    Example using an anonymous inner class:
```
 ByteIterable bytes =
     people.collectByte(new ByteFunction<Person>()
     {
         public byte byteValueOf(Person person)
         {
             return person.getCode();
         }
     });
 
```
    Specified by:
    
    collectByte in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectByte in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectByte in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectByte in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectByte in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectByte in interface com.gs.collections.api.RichIterable<T>
  - collectChar
```
public com.gs.collections.api.list.primitive.MutableCharList collectChar(com.gs.collections.api.block.function.primitive.CharFunction<? super T> charFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive char iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 CharIterable chars =
     people.collectChar(person -> person.getMiddleInitial());
 
```
    Example using an anonymous inner class:
```
 CharIterable chars =
     people.collectChar(new CharFunction<Person>()
     {
         public char charValueOf(Person person)
         {
             return person.getMiddleInitial();
         }
     });
 
```
    Specified by:
    
    collectChar in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectChar in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectChar in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectChar in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectChar in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectChar in interface com.gs.collections.api.RichIterable<T>
  - collectDouble
```
public com.gs.collections.api.list.primitive.MutableDoubleList collectDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> doubleFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive double iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 DoubleIterable doubles =
     people.collectDouble(person -> person.getMilesFromNorthPole());
 
```
    Example using an anonymous inner class:
```
 DoubleIterable doubles =
     people.collectDouble(new DoubleFunction<Person>()
     {
         public double doubleValueOf(Person person)
         {
             return person.getMilesFromNorthPole();
         }
     });
 
```
    Specified by:
    
    collectDouble in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectDouble in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectDouble in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectDouble in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectDouble in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectDouble in interface com.gs.collections.api.RichIterable<T>
  - collectFloat
```
public com.gs.collections.api.list.primitive.MutableFloatList collectFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> floatFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive float iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 FloatIterable floats =
     people.collectFloat(person -> person.getHeightInInches());
 
```
    Example using an anonymous inner class:
```
 FloatIterable floats =
     people.collectFloat(new FloatFunction<Person>()
     {
         public float floatValueOf(Person person)
         {
             return person.getHeightInInches();
         }
     });
 
```
    Specified by:
    
    collectFloat in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectFloat in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectFloat in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectFloat in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectFloat in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectFloat in interface com.gs.collections.api.RichIterable<T>
  - collectInt
```
public com.gs.collections.api.list.primitive.MutableIntList collectInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> intFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive int iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 IntIterable ints =
     people.collectInt(person -> person.getAge());
 
```
    Example using an anonymous inner class:
```
 IntIterable ints =
     people.collectInt(new IntFunction<Person>()
     {
         public int intValueOf(Person person)
         {
             return person.getAge();
         }
     });
 
```
    Specified by:
    
    collectInt in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectInt in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectInt in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectInt in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectInt in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectInt in interface com.gs.collections.api.RichIterable<T>
  - collectLong
```
public com.gs.collections.api.list.primitive.MutableLongList collectLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> longFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive long iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 LongIterable longs =
     people.collectLong(person -> person.getGuid());
 
```
    Example using an anonymous inner class:
```
 LongIterable longs =
     people.collectLong(new LongFunction<Person>()
     {
         public long longValueOf(Person person)
         {
             return person.getGuid();
         }
     });
 
```
    Specified by:
    
    collectLong in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectLong in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectLong in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectLong in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectLong in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectLong in interface com.gs.collections.api.RichIterable<T>
  - collectShort
```
public com.gs.collections.api.list.primitive.MutableShortList collectShort(com.gs.collections.api.block.function.primitive.ShortFunction<? super T> shortFunction)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new primitive short iterable with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 ShortIterable shorts =
     people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
 
```
    Example using an anonymous inner class:
```
 ShortIterable shorts =
     people.collectShort(new ShortFunction<Person>()
     {
         public short shortValueOf(Person person)
         {
             return person.getNumberOfJunkMailItemsReceivedPerMonth();
         }
     });
 
```
    Specified by:
    
    collectShort in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectShort in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectShort in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectShort in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectShort in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectShort in interface com.gs.collections.api.RichIterable<T>
  - selectInstancesOf
```
public <S> com.gs.collections.api.bag.sorted.MutableSortedBag<S> selectInstancesOf(java.lang.Class<S> clazz)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Returns all elements of the source collection that are instances of the Class clazz.
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface com.gs.collections.api.RichIterable<T>
  - collect
```
public <V> com.gs.collections.api.list.MutableList<V> collect(com.gs.collections.api.block.function.Function<? super T,? extends V> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    Example using a Java 8 lambda expression:
```
 RichIterable<String> names =
     people.collect(person -> person.getFirstName() + " " + person.getLastName());
 
```
    Example using an anonymous inner class:
```
 RichIterable<String> names =
     people.collect(new Function<Person, String>()
     {
         public String valueOf(Person person)
         {
             return person.getFirstName() + " " + person.getLastName();
         }
     });
 
```
    Specified by:
    
    collect in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collect in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collect in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collect in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collect in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collect in interface com.gs.collections.api.RichIterable<T>
  - zipWithIndex
```
public com.gs.collections.api.set.sorted.MutableSortedSet<com.gs.collections.api.tuple.Pair<T,java.lang.Integer>> zipWithIndex()
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Zips this RichIterable with its indices.
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface com.gs.collections.api.RichIterable<T>
    
    Returns:
    A new RichIterable containing pairs consisting of all elements of this RichIterable paired with their index. Indices start at 0.
    See Also:
    RichIterable.zip(Iterable)
  - collectWith
```
public <P,V> com.gs.collections.api.list.MutableList<V> collectWith(com.gs.collections.api.block.function.Function2<? super T,? super P,? extends V> function,
                                                           P parameter)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Same as RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block.
    Example using a Java 8 lambda expression:
```
 RichIterable<Integer> integers =
     Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
 
```
    Example using an anonymous inner class:
```
 Function2<Integer, Integer, Integer> addParameterFunction =
     new Function2<Integer, Integer, Integer>()
     {
         public Integer value(Integer each, Integer parameter)
         {
             return each + parameter;
         }
     };
 RichIterable<Integer> integers =
     Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
 
```
    Specified by:
    
    collectWith in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectWith in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectWith in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectWith in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectWith in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectWith in interface com.gs.collections.api.RichIterable<T>
    
    Parameters:
    function - A Function2 to use as the collect transformation function
    parameter - A parameter to pass in for evaluation of the second argument P in function
    
    Returns:
    A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
    See Also:
    RichIterable.collect(Function)
  - collectIf
```
public <V> com.gs.collections.api.list.MutableList<V> collectIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate,
                                                       com.gs.collections.api.block.function.Function<? super T,? extends V> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. This is the the optimized equivalent of calling iterable.select(predicate).collect(function).
    Example using a Java 8 lambda and method reference:
```
 RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString);
 
```
    Example using Predicates factory:
```
 RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
 
```
    Specified by:
    
    collectIf in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    collectIf in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    collectIf in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    collectIf in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    collectIf in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    collectIf in interface com.gs.collections.api.RichIterable<T>
  - flatCollect
```
public <V> com.gs.collections.api.list.MutableList<V> flatCollect(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    flatCollect is a special case of RichIterable.collect(Function). With collect, when the Function returns a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection instead. This method is commonly called flatMap.
    Consider the following example where we have a Person class, and each Person has a list of Address objects. Take the following Function:
```
 Function<Person, List<Address>> addressFunction = Person::getAddresses;
 MutableList<Person> people = ...;
 
```
    Using collect returns a collection of collections of addresses.
```
 MutableList<List<Address>> addresses = people.collect(addressFunction);
 
```
    Using flatCollect returns a single flattened list of addresses.
```
 MutableList<Address> addresses = people.flatCollect(addressFunction);
 
```
    Specified by:
    
    flatCollect in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    flatCollect in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    flatCollect in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    flatCollect in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    flatCollect in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    flatCollect in interface com.gs.collections.api.RichIterable<T>
    
    Parameters:
    function - The Function to apply
    
    Returns:
    a new flattened collection produced by applying the given function
  - groupBy
```
public <V> com.gs.collections.api.multimap.sortedbag.MutableSortedBagMultimap<V,T> groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable.
    Example using a Java 8 method reference:
```
 Multimap<String, Person> peopleByLastName =
     people.groupBy(Person::getLastName);
 
```
    Example using an anonymous inner class:
```
 Multimap<String, Person> peopleByLastName =
     people.groupBy(new Function<Person, String>()
     {
         public String value(Person person)
         {
             return person.getLastName();
         }
     });
 
```
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    groupBy in interface com.gs.collections.api.RichIterable<T>
  - groupByEach
```
public <V> com.gs.collections.api.multimap.sortedbag.MutableSortedBagMultimap<V,T> groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Similar to RichIterable.groupBy(Function), except the result of evaluating function will return a collection of keys for each value.
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.MutableBagIterable<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    groupByEach in interface com.gs.collections.api.RichIterable<T>
  - zip
```
public <S> com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.Pair<T,S>> zip(java.lang.Iterable<S> that)
```
    Description copied from interface: com.gs.collections.api.RichIterable
    
    Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs. If one of the two RichIterables is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    zip in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Specified by:
    
    zip in interface com.gs.collections.api.ordered.OrderedIterable<T>
    
    Specified by:
    
    zip in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Specified by:
    
    zip in interface com.gs.collections.api.ordered.SortedIterable<T>
    
    Specified by:
    
    zip in interface com.gs.collections.api.RichIterable<T>
    
    Type Parameters:
    S - the type of the second half of the returned pairs
    Parameters:
    that - The RichIterable providing the second half of each result pair
    
    Returns:
    A new RichIterable containing pairs consisting of corresponding elements of this RichIterable and that. The length of the returned RichIterable is the minimum of the lengths of this RichIterable and that.
  - asUnmodifiable
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> asUnmodifiable()
```
    Description copied from interface: com.gs.collections.api.bag.sorted.MutableSortedBag
    
    Returns an unmodifiable view of the set. The returned set will be Serializable if this set is Serializable.
    
    Specified by:
    
    asUnmodifiable in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    asUnmodifiable in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Returns:
    an unmodifiable view of this set
  - asSynchronized
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> asSynchronized()
```
    Description copied from interface: com.gs.collections.api.collection.MutableCollection
    Returns a synchronized (thread-safe) collection backed by this collection. In order to guarantee serial access, it is critical that all access to the backing collection is accomplished through the returned collection.
    It is imperative that the user manually synchronize on the returned collection when iterating over it using the standard JDK iterator or JDK 5 for loop.
```
  MutableCollection collection = myCollection.asSynchronized();
     ...
  synchronized(collection)
  {
      Iterator i = c.iterator(); // Must be in the synchronized block
      while (i.hasNext())
         foo(i.next());
  }
 
```
    Failure to follow this advice may result in non-deterministic behavior.
    The preferred way of iterating over a synchronized collection is to use the collection.forEach() method which is properly synchronized internally.
```
  MutableCollection collection = myCollection.asSynchronized();
     ...
  collection.forEach(new Procedure()
  {
      public void value(Object each)
      {
          ...
      }
  });
 
```
    The returned collection does not pass the hashCode and equals operations through to the backing collection, but relies on Object's equals and hashCode methods. This is necessary to preserve the contracts of these operations in the case that the backing collection is a set or a list.
    The returned collection will be serializable if this collection is serializable.
    Specified by:
    
    asSynchronized in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    asSynchronized in interface com.gs.collections.api.collection.MutableCollection<T>
    
    Returns:
    a synchronized view of this collection.
  - toImmutable
```
public com.gs.collections.api.bag.sorted.ImmutableSortedBag<T> toImmutable()
```
    Description copied from interface: com.gs.collections.api.bag.sorted.SortedBag
    
    Convert the SortedBag to an ImmutableSortedBag. If the bag is immutable, it returns itself. Not yet supported.
    
    Specified by:
    
    toImmutable in interface com.gs.collections.api.bag.Bag<T>
    
    Specified by:
    
    toImmutable in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    toImmutable in interface com.gs.collections.api.collection.MutableCollection<T>
  - drop
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> drop(int count)
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    
    Returns an iterable after skipping the first count elements or an empty iterable if the count is greater than the length of the iterable.
    
    Specified by:
    
    drop in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    drop in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    drop in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Parameters:
    count - the number of items to drop.
  - take
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> take(int count)
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    
    Returns the first count elements of the iterable or all the elements in the iterable if count is greater than the length of the iterable.
    
    Specified by:
    
    take in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    take in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    take in interface com.gs.collections.api.ordered.ReversibleIterable<T>
    
    Parameters:
    count - the number of items to take.
  - toReversed
```
public com.gs.collections.api.bag.sorted.MutableSortedBag<T> toReversed()
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    
    Returns a new ReversibleIterable in reverse order.
    
    Specified by:
    
    toReversed in interface com.gs.collections.api.bag.sorted.MutableSortedBag<T>
    
    Specified by:
    
    toReversed in interface com.gs.collections.api.bag.sorted.SortedBag<T>
    
    Specified by:
    
    toReversed in interface com.gs.collections.api.ordered.ReversibleIterable<T>
  - reverseForEach
```
public void reverseForEach(com.gs.collections.api.block.procedure.Procedure<? super T> procedure)
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    Evaluates the procedure for each element of the list iterating in reverse order.
```
e.g.
 people.reverseForEach(new Procedure()
 {
     public void value(Person person)
     {
         LOGGER.info(person.getName());
     }
 });
 
```
    Specified by:
    
    reverseForEach in interface com.gs.collections.api.ordered.ReversibleIterable<T>
  - asReversed
```
public com.gs.collections.api.LazyIterable<T> asReversed()
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    
    Returns a reversed view of this ReversibleIterable.
    
    Specified by:
    
    asReversed in interface com.gs.collections.api.ordered.ReversibleIterable<T>
  - detectLastIndex
```
public int detectLastIndex(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)
```
    Description copied from interface: com.gs.collections.api.ordered.ReversibleIterable
    
    Returns the index of the last element of the ReversibleIterable for which the predicate evaluates to true. Returns -1 if no element evaluates true for the predicate.
    
    Specified by:
    
    detectLastIndex in interface com.gs.collections.api.ordered.ReversibleIterable<T>
  - asParallel
```
public com.gs.collections.api.bag.ParallelBag<T> asParallel(java.util.concurrent.ExecutorService executorService,
                                                   int batchSize)
```

Class SynchronizedSortedBag<T>

Field Summary

Fields inherited from class com.gs.collections.impl.collection.AbstractSynchronizedRichIterable

Method Summary

Methods inherited from class com.gs.collections.impl.collection.mutable.AbstractSynchronizedMutableCollection

Methods inherited from class com.gs.collections.impl.collection.AbstractSynchronizedRichIterable

Methods inherited from class java.lang.Object

Methods inherited from interface com.gs.collections.api.bag.sorted.MutableSortedBag

Methods inherited from interface com.gs.collections.api.bag.sorted.SortedBag

Methods inherited from interface com.gs.collections.api.ordered.OrderedIterable

Methods inherited from interface com.gs.collections.api.RichIterable

Methods inherited from interface com.gs.collections.api.InternalIterable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.gs.collections.api.bag.Bag

Methods inherited from interface com.gs.collections.api.collection.MutableCollection

Methods inherited from interface java.util.Collection

Method Detail

of

of

getDelegate

with

without

withAll

withoutAll

newEmpty

clone

comparator

compareTo

writeReplace

addOccurrences

removeOccurrences

setOccurrences

topOccurrences

selectByOccurrences

bottomOccurrences

toMapOfItemToCount

forEachWithOccurrences

occurrencesOf

sizeDistinct

toStringOfItemToCount

indexOf

toStack

partitionWhile

distinct

takeWhile

dropWhile

corresponds

forEach

forEachWithIndex

detectIndex

tap

select

selectWith

reject

rejectWith

partition

partitionWith

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

selectInstancesOf

collect

zipWithIndex

collectWith

collectIf

flatCollect

groupBy

groupByEach

zip

asUnmodifiable

asSynchronized

toImmutable

drop

take

toReversed