java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<T>
- - org.eclipse.collections.impl.bag.AbstractBag<T>
  - - org.eclipse.collections.impl.bag.immutable.AbstractImmutableBagIterable<T>
    - - org.eclipse.collections.impl.bag.sorted.immutable.AbstractImmutableSortedBag<T>
      - org.eclipse.collections.impl.bag.sorted.immutable.ImmutableSortedBagImpl<T>

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<SortedBag<T>>, java.lang.Iterable<T>, java.util.Collection<T>, Bag<T>, ImmutableBagIterable<T>, ImmutableSortedBag<T>, SortedBag<T>, ImmutableCollection<T>, InternalIterable<T>, OrderedIterable<T>, ReversibleIterable<T>, SortedIterable<T>, RichIterable<T>
```
class ImmutableSortedBagImpl<T>
extends AbstractImmutableSortedBag<T>
implements java.io.Serializable
```

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private class ImmutableSortedBagImpl.InternalIterator

Field Summary

Fields
Modifier and Type	Field	Description
`private java.util.Comparator<? super T>`	`comparator`
`private T[]`	`elements`
`private int[]`	`occurrences`
`private static long`	`serialVersionUID`
`private int`	`size`

Constructor Summary

Constructors
Modifier	Constructor	Description
`(package private)`	`ImmutableSortedBagImpl(SortedBag<T> sortedBag)`
`private`	`ImmutableSortedBagImpl(T[] elements, int[] occurrences, java.util.Comparator<? super T> comparator)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`allSatisfy(Predicate<? super T> predicate)`	Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty.
`<P> boolean`	`allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`	Returns true if the predicate evaluates to true for every element of the collection, or returns false.
`boolean`	`allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`	Returns true if the predicate evaluates to true for all elements of the Bag.
`boolean`	`anySatisfy(Predicate<? super T> predicate)`	Returns true if the predicate evaluates to true for any element of the iterable.
`<P> boolean`	`anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`	Returns true if the predicate evaluates to true for any element of the collection, or return false.
`boolean`	`anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`	Returns true if the predicate evaluates to true for any element of the Bag.
`<V> ImmutableList<V>`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)`	Returns a new OrderedIterable using results obtained by applying the specified function to each element and its corresponding index.
`<V,R extends java.util.Collection<V>> R`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function, R target)`	Adds elements to the target Collection using results obtained by applying the specified function to each element and its corresponding index.
`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(SortedBag<T> otherBag)`
`boolean`	`contains(java.lang.Object object)`	Returns true if the iterable has an element which responds true to element.equals(object).
`<S> boolean`	`corresponds(OrderedIterable<S> other, 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`.
`T`	`detect(Predicate<? super T> predicate)`	Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true.
`int`	`detectIndex(Predicate<? super T> predicate)`	Returns the index of the first element of the `OrderedIterable` for which the `predicate` evaluates to true.
`private int`	`detectNotIndex(Predicate<? super T> predicate)`
`java.util.Optional<T>`	`detectOptional(Predicate<? super T> predicate)`	Returns the first element of the iterable for which the predicate evaluates to true as an Optional.
`T`	`detectWithOccurrences(ObjectIntPredicate<? super T> predicate)`	Returns an element of the Bag that satisfies the predicate or null if such an element does not exist
`ImmutableSortedSet<T>`	`distinct()`	Returns a new `SortedIterable` containing the distinct elements in this iterable.
`RichIterable<T>`	`distinctView()`	Returns an unmodifiable view on the distinct elements with the same complexity as the Bag implementation.
`ImmutableSortedBag<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.
`ImmutableSortedBag<T>`	`dropWhile(Predicate<? super T> predicate)`	Returns the final elements that do not satisfy the Predicate.
`void`	`each(Procedure<? super T> procedure)`	The procedure is executed for each element in the iterable.
`boolean`	`equals(java.lang.Object other)`	Two bags `b1` and `b2` are equal if `m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount())`.
`void`	`forEach(int fromIndex, int toIndex, Procedure<? super T> procedure)`	Iterates over the section of the iterable covered by the specified inclusive indexes.
`void`	`forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super T> objectIntProcedure)`	Iterates over the section of the iterable covered by the specified inclusive indexes.
`void`	`forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)`	Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
`void`	`forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)`	For each distinct item, with the number of occurrences, execute the specified procedure.
`T`	`getFirst()`	Returns the first element of an iterable.
`T`	`getLast()`	Returns the last element of an iterable.
`int`	`hashCode()`	Returns the hash code for this Bag, defined as this.`Bag.toMapOfItemToCount()`.hashCode().
`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.
`java.util.Iterator<T>`	`iterator()`
`T`	`max()`	Returns the maximum element out of this container based on the natural order.
`T`	`max(java.util.Comparator<? super T> comparator)`	Returns the maximum element out of this container based on the comparator.
`<V extends java.lang.Comparable<? super V>> T`	`maxBy(Function<? super T,? extends V> function)`	Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.
`T`	`min()`	Returns the minimum element out of this container based on the natural order.
`T`	`min(java.util.Comparator<? super T> comparator)`	Returns the minimum element out of this container based on the comparator.
`<V extends java.lang.Comparable<? super V>> T`	`minBy(Function<? super T,? extends V> function)`	Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.
`ImmutableSortedBag<T>`	`newWith(T element)`	This method is similar to the `with` method in `MutableCollection` with the difference that a new copy of this collection with the element appended will be returned.
`ImmutableSortedBag<T>`	`newWithAll(java.lang.Iterable<? extends T> elements)`	This method is similar to the `withAll` method in `MutableCollection` with the difference that a new copy of this collection with the elements appended will be returned.
`ImmutableSortedBag<T>`	`newWithout(T element)`	This method is similar to the `without` method in `MutableCollection` with the difference that a new copy of this collection with the element removed will be returned.
`boolean`	`noneSatisfy(Predicate<? super T> predicate)`	Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty.
`<P> boolean`	`noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`	Returns true if the predicate evaluates to false for every element of the collection, or return false.
`boolean`	`noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)`	Returns true if the Bag is empty or if the predicate evaluates to false for all elements of the Bag.
`int`	`occurrencesOf(java.lang.Object item)`	The occurrences of a distinct item in the bag.
`PartitionImmutableSortedBag<T>`	`partitionWhile(Predicate<? super T> predicate)`	Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
`int`	`size()`	Returns the number of items in this iterable.
`int`	`sizeDistinct()`	The size of the Bag when counting only distinct elements.
`ImmutableSortedBag<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.
`ImmutableSortedBag<T>`	`takeWhile(Predicate<? super T> predicate)`	Returns the initial elements that satisfy the Predicate.
`java.lang.Object[]`	`toArray()`	Converts this iterable to an array.
`<E> E[]`	`toArray(E[] array)`	Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable.
`MutableSortedMap<T,java.lang.Integer>`	`toMapOfItemToCount()`	Converts the Bag to a Map of the Item type to its count as an Integer.
`MutableList<T>`	`toSortedList()`	Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.
`MutableSortedSet<T>`	`toSortedSet()`	Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.
`MutableSortedSet<T>`	`toSortedSet(java.util.Comparator<? super T> comparator)`	Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.

Methods inherited from class org.eclipse.collections.impl.bag.sorted.immutable.AbstractImmutableSortedBag
bottomOccurrences, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, collectWithOccurrences, countBy, countByEach, countByWith, detectLastIndex, flatCollect, groupBy, groupByEach, groupByUniqueKey, newWithoutAll, partition, partitionWith, reject, rejectWith, select, selectByOccurrences, selectInstancesOf, selectWith, tap, toImmutable, topOccurrences, toReversed, writeReplace, zip, zip, zipWithIndex

Methods inherited from class org.eclipse.collections.impl.bag.immutable.AbstractImmutableBagIterable
add, addAll, castToCollection, clear, parallelStream, remove, removeAll, removeAllFrom, retainAll, shortCircuit, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLong

Methods inherited from class org.eclipse.collections.impl.bag.AbstractBag
collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, count, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoWith, occurrencesSortingBy, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toList, toListWithOccurrences, toSet, toSortedBag, toSortedBag, toSortedList, toStringOfItemToCount

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
appendString, appendString, asLazy, containsAll, containsAllArguments, containsAllIterable, countWith, detectWith, detectWithIfNone, detectWithOptional, forEach, forEachWith, groupByUniqueKey, into, isEmpty, toBiMap, toMap, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSetBy, toString, zipWithIndex

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

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

Methods inherited from interface java.util.Collection
containsAll, isEmpty, removeIf, toArray

Methods inherited from interface org.eclipse.collections.api.collection.ImmutableCollection
aggregateBy, aggregateInPlaceBy, castToCollection, parallelStream, reduceBy, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLong

Methods inherited from interface org.eclipse.collections.api.bag.sorted.ImmutableSortedBag
flatCollectWith, selectDuplicates, selectUnique, toImmutableSortedBag

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

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable
getFirstOptional, getLastOptional, rejectWithIndex, selectWithIndex, toStack, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.ordered.ReversibleIterable
asReversed, reverseForEach, reverseForEachWithIndex

Methods inherited from interface org.eclipse.collections.api.RichIterable
appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countByEach, countByWith, countWith, detectIfNone, detectWith, detectWithIfNone, detectWithOptional, 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, maxByOptional, maxOptional, maxOptional, minByOptional, minOptional, minOptional, notEmpty, reduce, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSetBy, toString

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - elements
```
private final T[] elements
```
  - occurrences
```
private final int[] occurrences
```
  - comparator
```
private final java.util.Comparator<? super T> comparator
```
  - size
```
private final int size
```
- Constructor Detail
  - ImmutableSortedBagImpl
```
ImmutableSortedBagImpl(SortedBag<T> sortedBag)
```
  - ImmutableSortedBagImpl
```
private ImmutableSortedBagImpl(T[] elements,
                               int[] occurrences,
                               java.util.Comparator<? super T> comparator)
```
- Method Detail
  - newWith
```
public ImmutableSortedBag<T> newWith(T element)
```
    Description copied from interface: ImmutableCollection
    
    This method is similar to the with method in MutableCollection with the difference that a new copy of this collection with the element appended will be returned.
    
    Specified by:
    
    newWith in interface ImmutableCollection<T>
    
    Specified by:
    
    newWith in interface ImmutableSortedBag<T>
  - newWithout
```
public ImmutableSortedBag<T> newWithout(T element)
```
    Description copied from interface: ImmutableCollection
    
    This method is similar to the without method in MutableCollection with the difference that a new copy of this collection with the element removed will be returned.
    
    Specified by:
    
    newWithout in interface ImmutableCollection<T>
    
    Specified by:
    
    newWithout in interface ImmutableSortedBag<T>
  - newWithAll
```
public ImmutableSortedBag<T> newWithAll(java.lang.Iterable<? extends T> elements)
```
    Description copied from interface: ImmutableCollection
    
    This method is similar to the withAll method in MutableCollection with the difference that a new copy of this collection with the elements appended will be returned.
    
    Specified by:
    
    newWithAll in interface ImmutableCollection<T>
    
    Specified by:
    
    newWithAll in interface ImmutableSortedBag<T>
  - comparator
```
public java.util.Comparator<? super T> comparator()
```
    Description copied from interface: 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 SortedBag<T>
    
    Specified by:
    
    comparator in interface SortedIterable<T>
  - min
```
public T min()
```
    Description copied from interface: RichIterable
    
    Returns the minimum element out of this container based on the natural order.
    
    Specified by:
    
    min in interface OrderedIterable<T>
    
    Specified by:
    
    min in interface RichIterable<T>
    
    Specified by:
    
    min in interface SortedBag<T>
    
    Specified by:
    
    min in interface SortedIterable<T>
    
    Overrides:
    
    min in class AbstractRichIterable<T>
  - min
```
public T min(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: RichIterable
    
    Returns the minimum element out of this container based on the comparator.
    
    Specified by:
    
    min in interface RichIterable<T>
    
    Overrides:
    
    min in class AbstractRichIterable<T>
  - minBy
```
public <V extends java.lang.Comparable<? super V>> T minBy(Function<? super T,? extends V> function)
```
    Description copied from interface: RichIterable
    
    Returns the minimum elements out of this container based on the natural order of the attribute returned by Function.
    
    Specified by:
    
    minBy in interface RichIterable<T>
    
    Overrides:
    
    minBy in class AbstractRichIterable<T>
  - max
```
public T max()
```
    Description copied from interface: RichIterable
    
    Returns the maximum element out of this container based on the natural order.
    
    Specified by:
    
    max in interface OrderedIterable<T>
    
    Specified by:
    
    max in interface RichIterable<T>
    
    Specified by:
    
    max in interface SortedBag<T>
    
    Specified by:
    
    max in interface SortedIterable<T>
    
    Overrides:
    
    max in class AbstractRichIterable<T>
  - max
```
public T max(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: RichIterable
    
    Returns the maximum element out of this container based on the comparator.
    
    Specified by:
    
    max in interface RichIterable<T>
    
    Overrides:
    
    max in class AbstractRichIterable<T>
  - maxBy
```
public <V extends java.lang.Comparable<? super V>> T maxBy(Function<? super T,? extends V> function)
```
    Description copied from interface: RichIterable
    
    Returns the maximum elements out of this container based on the natural order of the attribute returned by Function.
    
    Specified by:
    
    maxBy in interface RichIterable<T>
    
    Overrides:
    
    maxBy in class AbstractRichIterable<T>
  - takeWhile
```
public ImmutableSortedBag<T> takeWhile(Predicate<? super T> predicate)
```
    Description copied from interface: 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 ImmutableSortedBag<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 ImmutableSortedBag<T> dropWhile(Predicate<? super T> predicate)
```
    Description copied from interface: 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 ImmutableSortedBag<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>
  - detectIndex
```
public int detectIndex(Predicate<? super T> predicate)
```
    Description copied from interface: 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 OrderedIterable<T>
  - detectNotIndex
```
private int detectNotIndex(Predicate<? super T> predicate)
```
  - partitionWhile
```
public PartitionImmutableSortedBag<T> partitionWhile(Predicate<? super T> predicate)
```
    Description copied from interface: 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 OrderedIterable<T>
    
    Specified by:
    
    partitionWhile in interface ReversibleIterable<T>
    
    Specified by:
    
    partitionWhile in interface SortedBag<T>
    
    Specified by:
    
    partitionWhile in interface SortedIterable<T>
  - forEachWithOccurrences
```
public void forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)
```
    Description copied from interface: Bag
    
    For each distinct item, with the number of occurrences, execute the specified procedure.
    
    Specified by:
    
    forEachWithOccurrences in interface Bag<T>
  - anySatisfyWithOccurrences
```
public boolean anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Description copied from interface: Bag
    
    Returns true if the predicate evaluates to true for any element of the Bag. Returns false if the Bag is empty or if no element returns true for the predicate.
    
    Specified by:
    
    anySatisfyWithOccurrences in interface Bag<T>
  - allSatisfyWithOccurrences
```
public boolean allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Description copied from interface: Bag
    
    Returns true if the predicate evaluates to true for all elements of the Bag. Returns false if the Bag is empty or if not all elements return true for the predicate.
    
    Specified by:
    
    allSatisfyWithOccurrences in interface Bag<T>
  - noneSatisfyWithOccurrences
```
public boolean noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Description copied from interface: Bag
    
    Returns true if the Bag is empty or if the predicate evaluates to false for all elements of the Bag. Returns false if the predicate evaluates to true for at least one element of the Bag.
    
    Specified by:
    
    noneSatisfyWithOccurrences in interface Bag<T>
  - detectWithOccurrences
```
public T detectWithOccurrences(ObjectIntPredicate<? super T> predicate)
```
    Description copied from interface: Bag
    
    Returns an element of the Bag that satisfies the predicate or null if such an element does not exist
    
    Specified by:
    
    detectWithOccurrences in interface Bag<T>
  - sizeDistinct
```
public int sizeDistinct()
```
    Description copied from interface: Bag
    
    The size of the Bag when counting only distinct elements.
    
    Specified by:
    
    sizeDistinct in interface Bag<T>
  - size
```
public int size()
```
    Description copied from interface: RichIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface java.util.Collection<T>
    
    Specified by:
    
    size in interface RichIterable<T>
  - indexOf
```
public int indexOf(java.lang.Object object)
```
    Description copied from interface: 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 OrderedIterable<T>
    
    See Also:
    
    List.indexOf(Object)
  - getFirst
```
public T getFirst()
```
    Description copied from interface: RichIterable
    
    Returns the first element of an iterable. In the case of a List it is the element at the first index. In the case of any other Collection, it is the first element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.
    The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the first element could be any element from the Set.
    
    Specified by:
    
    getFirst in interface OrderedIterable<T>
    
    Specified by:
    
    getFirst in interface RichIterable<T>
  - getLast
```
public T getLast()
```
    Description copied from interface: RichIterable
    
    Returns the last element of an iterable. In the case of a List it is the element at the last index. In the case of any other Collection, it is the last element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.
    The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the last element could be any element from the Set.
    
    Specified by:
    
    getLast in interface OrderedIterable<T>
    
    Specified by:
    
    getLast in interface RichIterable<T>
  - forEach
```
public void forEach(int fromIndex,
                    int toIndex,
                    Procedure<? super T> procedure)
```
    Description copied from interface: OrderedIterable
    Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
    e.g. OrderedIterable<Person> people = FastList.newListWith(ted, mary, bob, sally) people.forEach(0, 1, person -> LOGGER.info(person.getName()));
    
    This code would output ted and mary's names.
    Specified by:
    
    forEach in interface OrderedIterable<T>
  - each
```
public void each(Procedure<? super T> procedure)
```
    Description copied from interface: RichIterable
    The procedure is executed for each element in the iterable.
    Example using a Java 8 lambda expression:
    people.each(person -> LOGGER.info(person.getName()));
    This method is a variant of InternalIterable.forEach(Procedure) that has a signature conflict with Iterable.forEach(java.util.function.Consumer).
    Specified by:
    
    each in interface RichIterable<T>
    
    See Also:
    
    InternalIterable.forEach(Procedure), Iterable.forEach(java.util.function.Consumer)
  - forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
```
    Description copied from interface: InternalIterable
    Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.
    Example using a Java 8 lambda:
    people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));
    
    Example using an anonymous inner class:
    people.forEachWithIndex(new ObjectIntProcedure<Person>() { public void value(Person person, int index) { LOGGER.info("Index: " + index + " person: " + person.getName()); } });
    Specified by:
    
    forEachWithIndex in interface InternalIterable<T>
    
    Specified by:
    
    forEachWithIndex in interface OrderedIterable<T>
    
    Overrides:
    
    forEachWithIndex in class AbstractRichIterable<T>
  - collectWithIndex
```
public <V> ImmutableList<V> collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)
```
    Description copied from interface: OrderedIterable
    
    Returns a new OrderedIterable using results obtained by applying the specified function to each element and its corresponding index.
    
    Specified by:
    
    collectWithIndex in interface ImmutableSortedBag<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 java.util.Collection<V>> R collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function,
                                                                      R target)
```
    Description copied from interface: OrderedIterable
    
    Adds elements to the target Collection using results obtained by applying the specified function to each element and its corresponding index.
    
    Specified by:
    
    collectWithIndex in interface OrderedIterable<T>
    
    Since:
    
    9.1.
  - forEachWithIndex
```
public void forEachWithIndex(int fromIndex,
                             int toIndex,
                             ObjectIntProcedure<? super T> objectIntProcedure)
```
    Description copied from interface: OrderedIterable
    Iterates over the section of the iterable covered by the specified inclusive indexes. The indexes are both inclusive.
    e.g. OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally) people.forEachWithIndex(0, 1, (person, index) -> LOGGER.info(person.getName()));
    
    This code would output ted and mary's names.
    Specified by:
    
    forEachWithIndex in interface OrderedIterable<T>
  - occurrencesOf
```
public int occurrencesOf(java.lang.Object item)
```
    Description copied from interface: Bag
    
    The occurrences of a distinct item in the bag.
    
    Specified by:
    
    occurrencesOf in interface Bag<T>
  - distinct
```
public ImmutableSortedSet<T> distinct()
```
    Description copied from interface: 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 ImmutableSortedBag<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>
    
    Returns:
    
    SortedIterable of distinct elements
  - corresponds
```
public <S> boolean corresponds(OrderedIterable<S> other,
                               Predicate2<? super T,? super S> predicate)
```
    Description copied from interface: 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 OrderedIterable<T>
  - toSortedList
```
public MutableList<T> toSortedList()
```
    Description copied from interface: RichIterable
    
    Converts the collection to a MutableList implementation and sorts it using the natural order of the elements.
    
    Specified by:
    
    toSortedList in interface RichIterable<T>
  - toSortedSet
```
public MutableSortedSet<T> toSortedSet()
```
    Description copied from interface: RichIterable
    
    Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.
    
    Specified by:
    
    toSortedSet in interface RichIterable<T>
    
    Overrides:
    
    toSortedSet in class AbstractBag<T>
  - toSortedSet
```
public MutableSortedSet<T> toSortedSet(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: RichIterable
    
    Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.
    
    Specified by:
    
    toSortedSet in interface RichIterable<T>
    
    Overrides:
    
    toSortedSet in class AbstractBag<T>
  - toArray
```
public java.lang.Object[] toArray()
```
    Description copied from interface: RichIterable
    
    Converts this iterable to an array.
    
    Specified by:
    
    toArray in interface java.util.Collection<T>
    
    Specified by:
    
    toArray in interface RichIterable<T>
    
    Overrides:
    
    toArray in class AbstractBag<T>
    
    See Also:
    
    Collection.toArray()
  - toArray
```
public <E> E[] toArray(E[] array)
```
    Description copied from interface: RichIterable
    
    Converts this iterable to an array using the specified target array, assuming the target array is as long or longer than the iterable.
    
    Specified by:
    
    toArray in interface java.util.Collection<T>
    
    Specified by:
    
    toArray in interface RichIterable<T>
    
    Overrides:
    
    toArray in class AbstractBag<T>
    
    See Also:
    
    Collection.toArray(Object[])
  - toMapOfItemToCount
```
public MutableSortedMap<T,java.lang.Integer> toMapOfItemToCount()
```
    Description copied from interface: Bag
    
    Converts the Bag to a Map of the Item type to its count as an Integer.
    
    Specified by:
    
    toMapOfItemToCount in interface Bag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface ImmutableBagIterable<T>
    
    Specified by:
    
    toMapOfItemToCount in interface ImmutableSortedBag<T>
    
    Specified by:
    
    toMapOfItemToCount in interface SortedBag<T>
  - compareTo
```
public int compareTo(SortedBag<T> otherBag)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<T>
  - allSatisfy
```
public boolean allSatisfy(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty. Otherwise, returns false.
    
    Specified by:
    
    allSatisfy in interface RichIterable<T>
    
    Overrides:
    
    allSatisfy in class AbstractRichIterable<T>
  - allSatisfyWith
```
public <P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to true for every element of the collection, or returns false.
    
    Specified by:
    
    allSatisfyWith in interface RichIterable<T>
    
    Overrides:
    
    allSatisfyWith in class AbstractRichIterable<T>
  - anySatisfy
```
public boolean anySatisfy(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to true for any element of the iterable. Returns false if the iterable is empty, or if no element returned true when evaluating the predicate.
    
    Specified by:
    
    anySatisfy in interface RichIterable<T>
    
    Overrides:
    
    anySatisfy in class AbstractRichIterable<T>
  - anySatisfyWith
```
public <P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to true for any element of the collection, or return false. Returns false if the collection is empty.
    
    Specified by:
    
    anySatisfyWith in interface RichIterable<T>
    
    Overrides:
    
    anySatisfyWith in class AbstractRichIterable<T>
  - noneSatisfy
```
public boolean noneSatisfy(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty. Otherwise, returns false.
    
    Specified by:
    
    noneSatisfy in interface RichIterable<T>
    
    Overrides:
    
    noneSatisfy in class AbstractRichIterable<T>
  - noneSatisfyWith
```
public <P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate,
                                   P parameter)
```
    Description copied from interface: RichIterable
    
    Returns true if the predicate evaluates to false for every element of the collection, or return false. Returns true if the collection is empty.
    
    Specified by:
    
    noneSatisfyWith in interface RichIterable<T>
    
    Overrides:
    
    noneSatisfyWith in class AbstractRichIterable<T>
  - detect
```
public T detect(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true. This method is commonly called find.
    Example using a Java 8 lambda expression:
    Person person = people.detect(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
    Specified by:
    
    detect in interface RichIterable<T>
    
    Overrides:
    
    detect in class AbstractRichIterable<T>
  - detectOptional
```
public java.util.Optional<T> detectOptional(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    Returns the first element of the iterable for which the predicate evaluates to true as an Optional. This method is commonly called find.
    Example using a Java 8 lambda expression:
    Person person = people.detectOptional(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
    Specified by:
    
    detectOptional in interface RichIterable<T>
    
    Overrides:
    
    detectOptional in class AbstractRichIterable<T>
  - contains
```
public boolean contains(java.lang.Object object)
```
    Description copied from interface: RichIterable
    
    Returns true if the iterable has an element which responds true to element.equals(object).
    
    Specified by:
    
    contains in interface java.util.Collection<T>
    
    Specified by:
    
    contains in interface RichIterable<T>
    
    Overrides:
    
    contains in class AbstractRichIterable<T>
  - iterator
```
public java.util.Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface java.util.Collection<T>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
  - take
```
public ImmutableSortedBag<T> take(int count)
```
    Description copied from interface: 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 ImmutableSortedBag<T>
    
    Specified by:
    
    take in interface ReversibleIterable<T>
    
    Specified by:
    
    take in interface SortedBag<T>
    
    Parameters:
    
    count - the number of items to take.
  - drop
```
public ImmutableSortedBag<T> drop(int count)
```
    Description copied from interface: 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 ImmutableSortedBag<T>
    
    Specified by:
    
    drop in interface ReversibleIterable<T>
    
    Specified by:
    
    drop in interface SortedBag<T>
    
    Parameters:
    
    count - the number of items to drop.
  - equals
```
public boolean equals(java.lang.Object other)
```
    Description copied from interface: Bag
    
    Two bags b1 and b2 are equal if m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount()).
    
    Specified by:
    
    equals in interface Bag<T>
    
    Specified by:
    
    equals in interface java.util.Collection<T>
    
    Overrides:
    
    equals in class java.lang.Object
    
    See Also:
    
    Map.equals(Object)
  - hashCode
```
public int hashCode()
```
    Description copied from interface: Bag
    
    Returns the hash code for this Bag, defined as this.Bag.toMapOfItemToCount().hashCode().
    
    Specified by:
    
    hashCode in interface Bag<T>
    
    Specified by:
    
    hashCode in interface java.util.Collection<T>
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    See Also:
    
    Map.hashCode()
  - distinctView
```
public RichIterable<T> distinctView()
```
    Description copied from interface: Bag
    
    Returns an unmodifiable view on the distinct elements with the same complexity as the Bag implementation.
    
    Specified by:
    
    distinctView in interface Bag<T>
    
    Returns:
    
    an unmodifiable view on the distinct elements of the Bag.

Class ImmutableSortedBagImpl<T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.bag.sorted.immutable.AbstractImmutableSortedBag

Methods inherited from class org.eclipse.collections.impl.bag.immutable.AbstractImmutableBagIterable

Methods inherited from class org.eclipse.collections.impl.bag.AbstractBag

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

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.collection.ImmutableCollection

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

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

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

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

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

Field Detail

serialVersionUID

elements

occurrences

comparator

size

Constructor Detail

ImmutableSortedBagImpl

ImmutableSortedBagImpl

Method Detail

newWith

newWithout

newWithAll

comparator

min

min

minBy

max

max

maxBy

takeWhile

dropWhile

detectIndex

detectNotIndex

partitionWhile

forEachWithOccurrences

anySatisfyWithOccurrences

allSatisfyWithOccurrences

noneSatisfyWithOccurrences

detectWithOccurrences

sizeDistinct

size

indexOf

getFirst

getLast

forEach

each

forEachWithIndex

collectWithIndex

collectWithIndex

forEachWithIndex

occurrencesOf

distinct

corresponds

toSortedList

toSortedSet

toSortedSet

toArray

toArray

toMapOfItemToCount

compareTo

allSatisfy

allSatisfyWith

anySatisfy

anySatisfyWith

noneSatisfy

noneSatisfyWith

detect

detectOptional

contains

iterator

take