java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<T>
- - org.eclipse.collections.impl.stack.immutable.ImmutableNotEmptyStack<T>

All Implemented Interfaces:

java.io.Serializable, java.lang.Iterable<T>, InternalIterable<T>, OrderedIterable<T>, RichIterable<T>, ImmutableStack<T>, StackIterable<T>
```
final class ImmutableNotEmptyStack<T>
extends AbstractRichIterable<T>
implements ImmutableStack<T>, java.io.Serializable
```

Field Summary

Fields
Modifier and Type Field Description

private T element

private ImmutableStack<T> next

private static long serialVersionUID

private int size

Constructor Summary

Constructors
Constructor Description

ImmutableNotEmptyStack(T element, ImmutableStack<T> next)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`checkNegativeCount(int count)`
`private void`	`checkSizeLessThanCount(int count)`
`private void`	`checkSizeLessThanOrEqualToIndex(int index)`
`private boolean`	`checkZeroCount(int count)`
`RichIterable<RichIterable<T>>`	`chunk(int size)`	Partitions elements in fixed size chunks.
`<V> ImmutableStack<V>`	`collect(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.
`ImmutableBooleanStack`	`collectBoolean(BooleanFunction<? super T> function)`	Returns a new primitive `boolean` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableByteStack`	`collectByte(ByteFunction<? super T> function)`	Returns a new primitive `byte` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableCharStack`	`collectChar(CharFunction<? super T> function)`	Returns a new primitive `char` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableDoubleStack`	`collectDouble(DoubleFunction<? super T> function)`	Returns a new primitive `double` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableFloatStack`	`collectFloat(FloatFunction<? super T> function)`	Returns a new primitive `float` iterable with the results of applying the specified function on each element of the source collection.
`<V> ImmutableStack<V>`	`collectIf(Predicate<? super T> predicate, 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.
`ImmutableIntStack`	`collectInt(IntFunction<? super T> function)`	Returns a new primitive `int` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableLongStack`	`collectLong(LongFunction<? super T> function)`	Returns a new primitive `long` iterable with the results of applying the specified function on each element of the source collection.
`ImmutableShortStack`	`collectShort(ShortFunction<? super T> function)`	Returns a new primitive `short` iterable with the results of applying the specified function on each element of the source collection.
`<P,V> ImmutableStack<V>`	`collectWith(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.
`<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`.
`<V> ImmutableBag<V>`	`countByEach(Function<? super T,? extends java.lang.Iterable<V>> function)`	This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
`int`	`detectIndex(Predicate<? super T> predicate)`	Returns the index of the first element of the `OrderedIterable` for which the `predicate` evaluates to true.
`ImmutableStack<T>`	`distinct()`	Returns a new `OrderedIterable` containing the distinct elements in this iterable.
`ImmutableStack<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 o)`	Follows the same general contract as `List.equals(Object)`, but for Stacks.
`<V> ImmutableStack<V>`	`flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)`	`flatCollect` is a special case of `RichIterable.collect(Function)`.
`void`	`forEach(int startIndex, int endIndex, 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.
`T`	`getFirst()`	Should return the same value as peek().
`T`	`getLast()`	Should not work as it violates the contract of a Stack.
`<V> ImmutableListMultimap<V,T>`	`groupBy(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> ImmutableListMultimap<V,T>`	`groupByEach(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.
`<V> ImmutableMap<V,T>`	`groupByUniqueKey(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 map, where the transformed value is the key.
`int`	`hashCode()`	Follows the same general contract as `List.hashCode()`, but for Stacks.
`boolean`	`hasSameElements(OrderedIterable<T> other)`
`boolean`	`isEmpty()`	Returns true if this iterable has zero items.
`java.util.Iterator<T>`	`iterator()`
`boolean`	`notEmpty()`	The English equivalent of !this.isEmpty()
`PartitionImmutableStack<T>`	`partition(Predicate<? super T> predicate)`	Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
`PartitionImmutableStack<T>`	`partitionWhile(Predicate<? super T> predicate)`	Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
`<P> PartitionImmutableStack<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`	Filters a collection into a PartitionIterable based on the evaluation of the predicate.
`T`	`peek()`	Returns the element at the top of the stack, without removing it from the stack.
`ListIterable<T>`	`peek(int count)`
`Pair<T,ImmutableStack<T>>`	`peekAndPop()`
`Pair<ListIterable<T>,ImmutableStack<T>>`	`peekAndPop(int count)`
`T`	`peekAt(int index)`	Returns the element at a specific index, without removing it from the stack.
`ImmutableStack<T>`	`pop()`
`ImmutableStack<T>`	`pop(int count)`
`ImmutableStack<T>`	`push(T item)`
`ImmutableStack<T>`	`reject(Predicate<? super T> predicate)`	Returns all elements of the source collection that return false when evaluating of the predicate.
`<P> ImmutableStack<T>`	`rejectWith(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`.
`ImmutableStack<T>`	`select(Predicate<? super T> predicate)`	Returns all elements of the source collection that return true when evaluating the predicate.
`<S> ImmutableStack<S>`	`selectInstancesOf(java.lang.Class<S> clazz)`	Returns all elements of the source collection that are instances of the Class `clazz`.
`<P> ImmutableStack<T>`	`selectWith(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`.
`int`	`size()`	Size takes linear time on ImmutableStacks.
`<V> ImmutableObjectDoubleMap<V>`	`sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)`	Groups and sums the values using the two specified functions.
`<V> ImmutableObjectDoubleMap<V>`	`sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)`	Groups and sums the values using the two specified functions.
`<V> ImmutableObjectLongMap<V>`	`sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)`	Groups and sums the values using the two specified functions.
`<V> ImmutableObjectLongMap<V>`	`sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)`	Groups and sums the values using the two specified functions.
`ImmutableStack<T>`	`takeWhile(Predicate<? super T> predicate)`	Returns the initial elements that satisfy the Predicate.
`ImmutableStack<T>`	`tap(Procedure<? super T> procedure)`	Executes the Procedure for each element in the iterable and returns `this`.
`ImmutableStack<T>`	`toImmutable()`	Converts the StackIterable to an immutable implementation.
`private java.lang.Object`	`writeReplace()`
`<S> ImmutableStack<Pair<T,S>>`	`zip(java.lang.Iterable<S> that)`	Returns a `OrderedIterable` formed from this `OrderedIterable` and another `Iterable` by combining corresponding elements in pairs.
`ImmutableStack<Pair<T,java.lang.Integer>>`	`zipWithIndex()`	Zips this `RichIterable` with its indices.

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, asLazy, collect, collectIf, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, forEach, forEachWith, forEachWithIndex, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toBiMap, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

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

Methods inherited from interface org.eclipse.collections.api.stack.ImmutableStack
aggregateBy, aggregateInPlaceBy, collectWithIndex, countBy, countByWith, flatCollectWith, reduceBy

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

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable
collectWithIndex, forEachWithIndex, getFirstOptional, getLastOptional, indexOf, max, min, rejectWithIndex, selectWithIndex, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, 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, makeString, makeString, makeString, makeString, max, maxBy, maxByOptional, maxOptional, maxOptional, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, reduce, reduceBy, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy

Methods inherited from interface org.eclipse.collections.api.stack.StackIterable
toStack, toString

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - element
```
private final T element
```
  - next
```
private final ImmutableStack<T> next
```
  - size
```
private final int size
```
- Constructor Detail
  - ImmutableNotEmptyStack
```
ImmutableNotEmptyStack(T element,
                       ImmutableStack<T> next)
```
- Method Detail
  - push
```
public ImmutableStack<T> push(T item)
```
    Specified by:
    
    push in interface ImmutableStack<T>
  - pop
```
public ImmutableStack<T> pop()
```
    Specified by:
    
    pop in interface ImmutableStack<T>
  - pop
```
public ImmutableStack<T> pop(int count)
```
    Specified by:
    
    pop in interface ImmutableStack<T>
  - peekAndPop
```
public Pair<T,ImmutableStack<T>> peekAndPop()
```
    Specified by:
    
    peekAndPop in interface ImmutableStack<T>
  - peekAndPop
```
public Pair<ListIterable<T>,ImmutableStack<T>> peekAndPop(int count)
```
    Specified by:
    
    peekAndPop in interface ImmutableStack<T>
  - peek
```
public T peek()
```
    Description copied from interface: StackIterable
    
    Returns the element at the top of the stack, without removing it from the stack.
    
    Specified by:
    
    peek in interface StackIterable<T>
    
    Returns:
    
    the top of the stack.
  - peek
```
public ListIterable<T> peek(int count)
```
    Specified by:
    
    peek in interface StackIterable<T>
    
    Returns:
    
    a ListIterable of the number of elements specified by the count, beginning with the top of the stack.
  - checkZeroCount
```
private boolean checkZeroCount(int count)
```
  - checkSizeLessThanCount
```
private void checkSizeLessThanCount(int count)
```
  - checkSizeLessThanOrEqualToIndex
```
private void checkSizeLessThanOrEqualToIndex(int index)
```
  - checkNegativeCount
```
private void checkNegativeCount(int count)
```
  - peekAt
```
public T peekAt(int index)
```
    Description copied from interface: StackIterable
    
    Returns the element at a specific index, without removing it from the stack.
    
    Specified by:
    
    peekAt in interface StackIterable<T>
    
    Parameters:
    
    index - the location to peek into
    
    Returns:
    
    the element at the specified index
  - getFirst
```
public T getFirst()
```
    Description copied from interface: StackIterable
    
    Should return the same value as peek().
    
    Specified by:
    
    getFirst in interface OrderedIterable<T>
    
    Specified by:
    
    getFirst in interface RichIterable<T>
    
    Specified by:
    
    getFirst in interface StackIterable<T>
  - getLast
```
public T getLast()
```
    Description copied from interface: StackIterable
    
    Should not work as it violates the contract of a Stack.
    
    Specified by:
    
    getLast in interface OrderedIterable<T>
    
    Specified by:
    
    getLast in interface RichIterable<T>
    
    Specified by:
    
    getLast in interface StackIterable<T>
  - select
```
public ImmutableStack<T> select(Predicate<? super T> predicate)
```
    Description copied from interface: 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"));
    Specified by:
    
    select in interface ImmutableStack<T>
    
    Specified by:
    
    select in interface OrderedIterable<T>
    
    Specified by:
    
    select in interface RichIterable<T>
    
    Specified by:
    
    select in interface StackIterable<T>
  - selectWith
```
public <P> ImmutableStack<T> selectWith(Predicate2<? super T,? super P> predicate,
                                        P parameter)
```
    Description copied from interface: 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));
    Specified by:
    
    selectWith in interface ImmutableStack<T>
    
    Specified by:
    
    selectWith in interface OrderedIterable<T>
    
    Specified by:
    
    selectWith in interface RichIterable<T>
    
    Specified by:
    
    selectWith in interface StackIterable<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 ImmutableStack<T> reject(Predicate<? super T> predicate)
```
    Description copied from interface: 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"));
    Specified by:
    
    reject in interface ImmutableStack<T>
    
    Specified by:
    
    reject in interface OrderedIterable<T>
    
    Specified by:
    
    reject in interface RichIterable<T>
    
    Specified by:
    
    reject in interface StackIterable<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> ImmutableStack<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                        P parameter)
```
    Description copied from interface: 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));
    Specified by:
    
    rejectWith in interface ImmutableStack<T>
    
    Specified by:
    
    rejectWith in interface OrderedIterable<T>
    
    Specified by:
    
    rejectWith in interface RichIterable<T>
    
    Specified by:
    
    rejectWith in interface StackIterable<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 PartitionImmutableStack<T> partition(Predicate<? super T> predicate)
```
    Description copied from interface: 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"));
    Specified by:
    
    partition in interface ImmutableStack<T>
    
    Specified by:
    
    partition in interface OrderedIterable<T>
    
    Specified by:
    
    partition in interface RichIterable<T>
    
    Specified by:
    
    partition in interface StackIterable<T>
  - partitionWith
```
public <P> PartitionImmutableStack<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                    P parameter)
```
    Description copied from interface: 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");
    Specified by:
    
    partitionWith in interface ImmutableStack<T>
    
    Specified by:
    
    partitionWith in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWith in interface RichIterable<T>
    
    Specified by:
    
    partitionWith in interface StackIterable<T>
  - selectInstancesOf
```
public <S> ImmutableStack<S> selectInstancesOf(java.lang.Class<S> clazz)
```
    Description copied from interface: RichIterable
    Returns all elements of the source collection that are instances of the Class clazz.
    RichIterable<Integer> integers = List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
    Specified by:
    
    selectInstancesOf in interface ImmutableStack<T>
    
    Specified by:
    
    selectInstancesOf in interface OrderedIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface StackIterable<T>
  - collect
```
public <V> ImmutableStack<V> collect(Function<? super T,? extends V> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collect in interface ImmutableStack<T>
    
    Specified by:
    
    collect in interface OrderedIterable<T>
    
    Specified by:
    
    collect in interface RichIterable<T>
    
    Specified by:
    
    collect in interface StackIterable<T>
  - collectBoolean
```
public ImmutableBooleanStack collectBoolean(BooleanFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectBoolean in interface ImmutableStack<T>
    
    Specified by:
    
    collectBoolean in interface OrderedIterable<T>
    
    Specified by:
    
    collectBoolean in interface RichIterable<T>
    
    Specified by:
    
    collectBoolean in interface StackIterable<T>
  - collectByte
```
public ImmutableByteStack collectByte(ByteFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectByte in interface ImmutableStack<T>
    
    Specified by:
    
    collectByte in interface OrderedIterable<T>
    
    Specified by:
    
    collectByte in interface RichIterable<T>
    
    Specified by:
    
    collectByte in interface StackIterable<T>
  - collectChar
```
public ImmutableCharStack collectChar(CharFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectChar in interface ImmutableStack<T>
    
    Specified by:
    
    collectChar in interface OrderedIterable<T>
    
    Specified by:
    
    collectChar in interface RichIterable<T>
    
    Specified by:
    
    collectChar in interface StackIterable<T>
  - collectDouble
```
public ImmutableDoubleStack collectDouble(DoubleFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectDouble in interface ImmutableStack<T>
    
    Specified by:
    
    collectDouble in interface OrderedIterable<T>
    
    Specified by:
    
    collectDouble in interface RichIterable<T>
    
    Specified by:
    
    collectDouble in interface StackIterable<T>
  - collectFloat
```
public ImmutableFloatStack collectFloat(FloatFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectFloat in interface ImmutableStack<T>
    
    Specified by:
    
    collectFloat in interface OrderedIterable<T>
    
    Specified by:
    
    collectFloat in interface RichIterable<T>
    
    Specified by:
    
    collectFloat in interface StackIterable<T>
  - collectInt
```
public ImmutableIntStack collectInt(IntFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectInt in interface ImmutableStack<T>
    
    Specified by:
    
    collectInt in interface OrderedIterable<T>
    
    Specified by:
    
    collectInt in interface RichIterable<T>
    
    Specified by:
    
    collectInt in interface StackIterable<T>
  - collectLong
```
public ImmutableLongStack collectLong(LongFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectLong in interface ImmutableStack<T>
    
    Specified by:
    
    collectLong in interface OrderedIterable<T>
    
    Specified by:
    
    collectLong in interface RichIterable<T>
    
    Specified by:
    
    collectLong in interface StackIterable<T>
  - collectShort
```
public ImmutableShortStack collectShort(ShortFunction<? super T> function)
```
    Description copied from interface: 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());
    Specified by:
    
    collectShort in interface ImmutableStack<T>
    
    Specified by:
    
    collectShort in interface OrderedIterable<T>
    
    Specified by:
    
    collectShort in interface RichIterable<T>
    
    Specified by:
    
    collectShort in interface StackIterable<T>
  - collectWith
```
public <P,V> ImmutableStack<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                                 P parameter)
```
    Description copied from interface: 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));
    Specified by:
    
    collectWith in interface ImmutableStack<T>
    
    Specified by:
    
    collectWith in interface OrderedIterable<T>
    
    Specified by:
    
    collectWith in interface RichIterable<T>
    
    Specified by:
    
    collectWith in interface StackIterable<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> ImmutableStack<V> collectIf(Predicate<? super T> predicate,
                                       Function<? super T,? extends V> function)
```
    Description copied from interface: 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 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 ImmutableStack<T>
    
    Specified by:
    
    collectIf in interface OrderedIterable<T>
    
    Specified by:
    
    collectIf in interface RichIterable<T>
    
    Specified by:
    
    collectIf in interface StackIterable<T>
  - flatCollect
```
public <V> ImmutableStack<V> flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: 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; RichIterable<Person> people = ...;
    Using collect returns a collection of collections of addresses.
    RichIterable<List<Address>> addresses = people.collect(addressFunction);
    Using flatCollect returns a single flattened list of addresses.
    RichIterable<Address> addresses = people.flatCollect(addressFunction);
    Specified by:
    
    flatCollect in interface ImmutableStack<T>
    
    Specified by:
    
    flatCollect in interface OrderedIterable<T>
    
    Specified by:
    
    flatCollect in interface RichIterable<T>
    
    Specified by:
    
    flatCollect in interface StackIterable<T>
    
    Parameters:
    
    function - The Function to apply
    
    Returns:
    
    a new flattened collection produced by applying the given function
  - sumByInt
```
public <V> ImmutableObjectLongMap<V> sumByInt(Function<? super T,? extends V> groupBy,
                                              IntFunction<? super T> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByInt in interface ImmutableStack<T>
    
    Specified by:
    
    sumByInt in interface RichIterable<T>
  - sumByFloat
```
public <V> ImmutableObjectDoubleMap<V> sumByFloat(Function<? super T,? extends V> groupBy,
                                                  FloatFunction<? super T> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByFloat in interface ImmutableStack<T>
    
    Specified by:
    
    sumByFloat in interface RichIterable<T>
  - sumByLong
```
public <V> ImmutableObjectLongMap<V> sumByLong(Function<? super T,? extends V> groupBy,
                                               LongFunction<? super T> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByLong in interface ImmutableStack<T>
    
    Specified by:
    
    sumByLong in interface RichIterable<T>
  - sumByDouble
```
public <V> ImmutableObjectDoubleMap<V> sumByDouble(Function<? super T,? extends V> groupBy,
                                                   DoubleFunction<? super T> function)
```
    Description copied from interface: RichIterable
    
    Groups and sums the values using the two specified functions.
    
    Specified by:
    
    sumByDouble in interface ImmutableStack<T>
    
    Specified by:
    
    sumByDouble in interface RichIterable<T>
  - groupBy
```
public <V> ImmutableListMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
    Description copied from interface: 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);
    Specified by:
    
    groupBy in interface ImmutableStack<T>
    
    Specified by:
    
    groupBy in interface OrderedIterable<T>
    
    Specified by:
    
    groupBy in interface RichIterable<T>
    
    Specified by:
    
    groupBy in interface StackIterable<T>
  - groupByEach
```
public <V> ImmutableListMultimap<V,T> groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: 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 ImmutableStack<T>
    
    Specified by:
    
    groupByEach in interface OrderedIterable<T>
    
    Specified by:
    
    groupByEach in interface RichIterable<T>
    
    Specified by:
    
    groupByEach in interface StackIterable<T>
  - groupByUniqueKey
```
public <V> ImmutableMap<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
```
    Description copied from interface: RichIterable
    
    For each element of the iterable, the function is evaluated, and the results of these evaluations are collected into a new map, where the transformed value is the key. The generated keys must each be unique, or else an exception is thrown.
    
    Specified by:
    
    groupByUniqueKey in interface ImmutableStack<T>
    
    Specified by:
    
    groupByUniqueKey in interface RichIterable<T>
    
    See Also:
    
    RichIterable.groupBy(Function)
  - zip
```
public <S> ImmutableStack<Pair<T,S>> zip(java.lang.Iterable<S> that)
```
    Description copied from interface: OrderedIterable
    
    Returns a OrderedIterable formed from this OrderedIterable and another Iterable by combining corresponding elements in pairs. The second Iterable should also be ordered. If one of the two Iterables is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface ImmutableStack<T>
    
    Specified by:
    
    zip in interface OrderedIterable<T>
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Specified by:
    
    zip in interface StackIterable<T>
    
    Type Parameters:
    
    S - the type of the second half of the returned pairs
    
    Parameters:
    
    that - The Iterable providing the second half of each result pair
    
    Returns:
    
    A new OrderedIterable containing pairs consisting of corresponding elements of this OrderedIterable and that. The length of the returned OrderedIterable is the minimum of the lengths of this OrderedIterable and that.
  - zipWithIndex
```
public ImmutableStack<Pair<T,java.lang.Integer>> zipWithIndex()
```
    Description copied from interface: RichIterable
    
    Zips this RichIterable with its indices.
    
    Specified by:
    
    zipWithIndex in interface ImmutableStack<T>
    
    Specified by:
    
    zipWithIndex in interface OrderedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Specified by:
    
    zipWithIndex in interface StackIterable<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)
  - toImmutable
```
public ImmutableStack<T> toImmutable()
```
    Description copied from interface: StackIterable
    
    Converts the StackIterable to an immutable implementation. Returns this for immutable stacks.
    
    Specified by:
    
    toImmutable in interface StackIterable<T>
  - chunk
```
public RichIterable<RichIterable<T>> chunk(int size)
```
    Description copied from interface: RichIterable
    
    Partitions elements in fixed size chunks.
    
    Specified by:
    
    chunk in interface RichIterable<T>
    
    Parameters:
    
    size - the number of elements per chunk
    
    Returns:
    
    A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.
  - countByEach
```
public <V> ImmutableBag<V> countByEach(Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Description copied from interface: RichIterable
    
    This method will count the number of occurrences of each value calculated by applying the function to each element of the collection.
    
    Specified by:
    
    countByEach in interface ImmutableStack<T>
    
    Specified by:
    
    countByEach in interface RichIterable<T>
    
    Overrides:
    
    countByEach in class AbstractRichIterable<T>
  - size
```
public int size()
```
    Description copied from interface: ImmutableStack
    
    Size takes linear time on ImmutableStacks.
    
    Specified by:
    
    size in interface ImmutableStack<T>
    
    Specified by:
    
    size in interface RichIterable<T>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: RichIterable
    
    Returns true if this iterable has zero items.
    
    Specified by:
    
    isEmpty in interface RichIterable<T>
    
    Overrides:
    
    isEmpty in class AbstractRichIterable<T>
  - notEmpty
```
public boolean notEmpty()
```
    Description copied from interface: RichIterable
    
    The English equivalent of !this.isEmpty()
    
    Specified by:
    
    notEmpty in interface RichIterable<T>
  - tap
```
public ImmutableStack<T> tap(Procedure<? super T> procedure)
```
    Description copied from interface: 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()));
    Specified by:
    
    tap in interface ImmutableStack<T>
    
    Specified by:
    
    tap in interface OrderedIterable<T>
    
    Specified by:
    
    tap in interface RichIterable<T>
    
    Specified by:
    
    tap in interface StackIterable<T>
    
    See Also:
    
    RichIterable.each(Procedure), RichIterable.forEach(Procedure)
  - 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)
  - takeWhile
```
public ImmutableStack<T> takeWhile(Predicate<? super T> predicate)
```
    Description copied from interface: OrderedIterable
    
    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 ImmutableStack<T>
    
    Specified by:
    
    takeWhile in interface OrderedIterable<T>
    
    Specified by:
    
    takeWhile in interface StackIterable<T>
  - dropWhile
```
public ImmutableStack<T> dropWhile(Predicate<? super T> predicate)
```
    Description copied from interface: OrderedIterable
    
    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 ImmutableStack<T>
    
    Specified by:
    
    dropWhile in interface OrderedIterable<T>
    
    Specified by:
    
    dropWhile in interface StackIterable<T>
  - partitionWhile
```
public PartitionImmutableStack<T> partitionWhile(Predicate<? super T> predicate)
```
    Description copied from interface: OrderedIterable
    
    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 ImmutableStack<T>
    
    Specified by:
    
    partitionWhile in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWhile in interface StackIterable<T>
  - distinct
```
public ImmutableStack<T> distinct()
```
    Description copied from interface: OrderedIterable
    
    Returns a new OrderedIterable 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 ImmutableStack<T>
    
    Specified by:
    
    distinct in interface OrderedIterable<T>
    
    Specified by:
    
    distinct in interface StackIterable<T>
    
    Returns:
    
    OrderedIterable 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>
  - hasSameElements
```
public boolean hasSameElements(OrderedIterable<T> other)
```
  - forEach
```
public void forEach(int startIndex,
                    int endIndex,
                    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>
  - 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>
  - 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>
  - iterator
```
public java.util.Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Description copied from interface: StackIterable
    
    Follows the same general contract as List.equals(Object), but for Stacks.
    
    Specified by:
    
    equals in interface StackIterable<T>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: StackIterable
    
    Follows the same general contract as List.hashCode(), but for Stacks.
    
    Specified by:
    
    hashCode in interface StackIterable<T>
    
    Overrides:
    
    hashCode in class java.lang.Object
  - writeReplace
```
private java.lang.Object writeReplace()
```

Modifier and Type	Field	Description
`private T`	`element`
`private ImmutableStack<T>`	`next`
`private static long`	`serialVersionUID`
`private int`	`size`

Class ImmutableNotEmptyStack<T>

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.stack.ImmutableStack

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

Methods inherited from interface java.lang.Iterable

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

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

Methods inherited from interface org.eclipse.collections.api.stack.StackIterable

Field Detail

serialVersionUID

element

next

size

Constructor Detail

ImmutableNotEmptyStack

Method Detail

push

pop

pop

peekAndPop

peekAndPop

peek

peek

checkZeroCount

checkSizeLessThanCount

checkSizeLessThanOrEqualToIndex

checkNegativeCount

peekAt

getFirst

getLast

select

selectWith

reject

rejectWith

partition

partitionWith

selectInstancesOf

collect

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

collectWith

collectIf

flatCollect

sumByInt

sumByFloat

sumByLong

sumByDouble

groupBy

groupByEach

groupByUniqueKey

zip

zipWithIndex

toImmutable

chunk

countByEach

size

isEmpty

notEmpty

tap

each

takeWhile

dropWhile

partitionWhile

distinct

corresponds

hasSameElements

forEach

forEachWithIndex

detectIndex

iterator