java.lang.Object
- org.eclipse.collections.impl.stack.mutable.SynchronizedStack<T>

All Implemented Interfaces:

Serializable, Iterable<T>, InternalIterable<T>, OrderedIterable<T>, RichIterable<T>, MutableStack<T>, StackIterable<T>
```
public final class SynchronizedStack<T>
extends Object
implements MutableStack<T>, Serializable
```
A synchronized view of a MutableStack. It is imperative that the user manually synchronize on the collection when iterating over it using the standard JDK iterator or JDK 5 for loop, as per Collections.synchronizedCollection(Collection).

See Also:

MutableStack.asSynchronized(), Serialized Form

Constructor Summary

Constructors
Constructor Description

SynchronizedStack(MutableStack<T> newStack)

SynchronizedStack(MutableStack<T> newStack, Object newLock)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`<K,V> MutableMap<K,V>`	`aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)`
`<K,V> MutableMap<K,V>`	`aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)`
`boolean`	`allSatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`anySatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`void`	`appendString(Appendable appendable)`
`void`	`appendString(Appendable appendable, String separator)`
`void`	`appendString(Appendable appendable, String start, String separator, String end)`
`LazyIterable<T>`	`asLazy()`
`MutableStack<T>`	`asSynchronized()`
`MutableStack<T>`	`asUnmodifiable()`
`RichIterable<RichIterable<T>>`	`chunk(int size)`
`void`	`clear()`
`<V> MutableStack<V>`	`collect(Function<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collect(Function<? super T,? extends V> function, R target)`
`MutableBooleanStack`	`collectBoolean(BooleanFunction<? super T> booleanFunction)`
`<R extends MutableBooleanCollection> R`	`collectBoolean(BooleanFunction<? super T> booleanFunction, R target)`
`MutableByteStack`	`collectByte(ByteFunction<? super T> byteFunction)`
`<R extends MutableByteCollection> R`	`collectByte(ByteFunction<? super T> byteFunction, R target)`
`MutableCharStack`	`collectChar(CharFunction<? super T> charFunction)`
`<R extends MutableCharCollection> R`	`collectChar(CharFunction<? super T> charFunction, R target)`
`MutableDoubleStack`	`collectDouble(DoubleFunction<? super T> doubleFunction)`
`<R extends MutableDoubleCollection> R`	`collectDouble(DoubleFunction<? super T> doubleFunction, R target)`
`MutableFloatStack`	`collectFloat(FloatFunction<? super T> floatFunction)`
`<R extends MutableFloatCollection> R`	`collectFloat(FloatFunction<? super T> floatFunction, R target)`
`<V> MutableStack<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function, R target)`
`MutableIntStack`	`collectInt(IntFunction<? super T> intFunction)`
`<R extends MutableIntCollection> R`	`collectInt(IntFunction<? super T> intFunction, R target)`
`MutableLongStack`	`collectLong(LongFunction<? super T> longFunction)`
`<R extends MutableLongCollection> R`	`collectLong(LongFunction<? super T> longFunction, R target)`
`MutableShortStack`	`collectShort(ShortFunction<? super T> shortFunction)`
`<R extends MutableShortCollection> R`	`collectShort(ShortFunction<? super T> shortFunction, R target)`
`<P,V> MutableStack<V>`	`collectWith(Function2<? super T,? super P,? extends V> function, P parameter)`
`<P,V,R extends Collection<V>> R`	`collectWith(Function2<? super T,? super P,? extends V> function, P parameter, R targetCollection)`
`<V> MutableStack<V>`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function, R target)`
`boolean`	`contains(Object object)`
`boolean`	`containsAll(Collection<?> source)`
`boolean`	`containsAllArguments(Object... elements)`
`boolean`	`containsAllIterable(Iterable<?> source)`
`boolean`	`containsAny(Collection<?> source)`
`boolean`	`containsAnyIterable(Iterable<?> source)`
`boolean`	`containsNone(Collection<?> source)`
`boolean`	`containsNoneIterable(Iterable<?> source)`
`<S> boolean`	`corresponds(OrderedIterable<S> other, Predicate2<? super T,? super S> predicate)`
`int`	`count(Predicate<? super T> predicate)`
`<P> int`	`countWith(Predicate2<? super T,? super P> predicate, P parameter)`
`T`	`detect(Predicate<? super T> predicate)`
`T`	`detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)`
`int`	`detectIndex(Predicate<? super T> predicate)`
`Optional<T>`	`detectOptional(Predicate<? super T> predicate)`
`<P> T`	`detectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P> T`	`detectWithIfNone(Predicate2<? super T,? super P> predicate, P parameter, Function0<? extends T> function)`
`<P> Optional<T>`	`detectWithOptional(Predicate2<? super T,? super P> predicate, P parameter)`
`MutableStack<T>`	`distinct()`
`MutableStack<T>`	`dropWhile(Predicate<? super T> predicate)`
`void`	`each(Procedure<? super T> procedure)`
`boolean`	`equals(Object obj)`
`<V> MutableStack<V>`	`flatCollect(Function<? super T,? extends Iterable<V>> function)`
`<V,R extends Collection<V>> R`	`flatCollect(Function<? super T,? extends Iterable<V>> function, R target)`
`<R extends MutableBooleanCollection> R`	`flatCollectBoolean(Function<? super T,? extends BooleanIterable> function, R target)`
`<R extends MutableByteCollection> R`	`flatCollectByte(Function<? super T,? extends ByteIterable> function, R target)`
`<R extends MutableCharCollection> R`	`flatCollectChar(Function<? super T,? extends CharIterable> function, R target)`
`<R extends MutableDoubleCollection> R`	`flatCollectDouble(Function<? super T,? extends DoubleIterable> function, R target)`
`<R extends MutableFloatCollection> R`	`flatCollectFloat(Function<? super T,? extends FloatIterable> function, R target)`
`<R extends MutableIntCollection> R`	`flatCollectInt(Function<? super T,? extends IntIterable> function, R target)`
`<R extends MutableLongCollection> R`	`flatCollectLong(Function<? super T,? extends LongIterable> function, R target)`
`<R extends MutableShortCollection> R`	`flatCollectShort(Function<? super T,? extends ShortIterable> function, R target)`
`void`	`forEach(int startIndex, int endIndex, Procedure<? super T> procedure)`
`<P> void`	`forEachWith(Procedure2<? super T,? super P> procedure, P parameter)`
`void`	`forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super T> objectIntProcedure)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)`
`T`	`getFirst()`
`Optional<T>`	`getFirstOptional()`
`T`	`getLast()`
`Optional<T>`	`getLastOptional()`
`T`	`getOnly()`
`<V> MutableListMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)`
`<V,R extends MutableMultimap<V,T>> R`	`groupBy(Function<? super T,? extends V> function, R target)`
`<V> MutableListMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)`
`<V,R extends MutableMultimap<V,T>> R`	`groupByEach(Function<? super T,? extends Iterable<V>> function, R target)`
`<V> MutableMap<V,T>`	`groupByUniqueKey(Function<? super T,? extends V> function)`
`<V,R extends MutableMapIterable<V,T>> R`	`groupByUniqueKey(Function<? super T,? extends V> function, R target)`
`int`	`hashCode()`
`int`	`indexOf(Object object)`
`double`	`injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super T> doubleObjectToDoubleFunction)`
`float`	`injectInto(float injectedValue, FloatObjectToFloatFunction<? super T> floatObjectToFloatFunction)`
`int`	`injectInto(int injectedValue, IntObjectToIntFunction<? super T> intObjectToIntFunction)`
`long`	`injectInto(long injectedValue, LongObjectToLongFunction<? super T> longObjectToLongFunction)`
`<IV> IV`	`injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function)`
`<R extends Collection<T>> R`	`into(R target)`
`boolean`	`isEmpty()`
`Iterator<T>`	`iterator()`
`String`	`makeString()`
`String`	`makeString(String separator)`
`String`	`makeString(String start, String separator, String end)`
`T`	`max()`
`T`	`max(Comparator<? super T> comparator)`
`<V extends Comparable<? super V>> T`	`maxBy(Function<? super T,? extends V> function)`
`T`	`min()`
`T`	`min(Comparator<? super T> comparator)`
`<V extends Comparable<? super V>> T`	`minBy(Function<? super T,? extends V> function)`
`boolean`	`noneSatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`notEmpty()`
`static <T,S extends MutableStack<T>> SynchronizedStack<T>`	`of(S stack)`	This method will take a MutableStack and wrap it directly in a SynchronizedStack.
`PartitionMutableStack<T>`	`partition(Predicate<? super T> predicate)`
`PartitionMutableStack<T>`	`partitionWhile(Predicate<? super T> predicate)`
`<P> PartitionMutableStack<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`
`T`	`peek()`
`ListIterable<T>`	`peek(int count)`
`T`	`peekAt(int index)`
`T`	`pop()`
`ListIterable<T>`	`pop(int count)`
`<R extends Collection<T>> R`	`pop(int count, R targetCollection)`
`void`	`push(T item)`
`MutableStack<T>`	`reject(Predicate<? super T> predicate)`
`<R extends Collection<T>> R`	`reject(Predicate<? super T> predicate, R target)`
`<P> MutableStack<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P,R extends Collection<T>> R`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`<R extends Collection<T>> R`	`rejectWithIndex(ObjectIntPredicate<? super T> predicate, R target)`
`MutableStack<T>`	`select(Predicate<? super T> predicate)`
`<R extends Collection<T>> R`	`select(Predicate<? super T> predicate, R target)`
`<S> MutableStack<S>`	`selectInstancesOf(Class<S> clazz)`
`<P> MutableStack<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P,R extends Collection<T>> R`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`<R extends Collection<T>> R`	`selectWithIndex(ObjectIntPredicate<? super T> predicate, R target)`
`int`	`size()`
`<V> MutableObjectDoubleMap<V>`	`sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)`
`<V> MutableObjectDoubleMap<V>`	`sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)`
`<V> MutableObjectLongMap<V>`	`sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)`
`<V> MutableObjectLongMap<V>`	`sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)`
`double`	`sumOfDouble(DoubleFunction<? super T> doubleFunction)`
`double`	`sumOfFloat(FloatFunction<? super T> floatFunction)`
`long`	`sumOfInt(IntFunction<? super T> intFunction)`
`long`	`sumOfLong(LongFunction<? super T> longFunction)`
`MutableStack<T>`	`takeWhile(Predicate<? super T> predicate)`
`MutableStack<T>`	`tap(Procedure<? super T> procedure)`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`MutableBag<T>`	`toBag()`
`<NK,NV> MutableBiMap<NK,NV>`	`toBiMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)`
`ImmutableStack<T>`	`toImmutable()`
`MutableList<T>`	`toList()`
`<NK,NV> MutableMap<NK,NV>`	`toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)`
`<NK,NV,R extends Map<NK,NV>> R`	`toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction, R target)`
`MutableSet<T>`	`toSet()`
`MutableSortedBag<T>`	`toSortedBag()`
`MutableSortedBag<T>`	`toSortedBag(Comparator<? super T> comparator)`
`MutableList<T>`	`toSortedList()`
`MutableList<T>`	`toSortedList(Comparator<? super T> comparator)`
`<NK,NV> MutableSortedMap<NK,NV>`	`toSortedMap(Comparator<? super NK> comparator, Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)`
`<NK,NV> MutableSortedMap<NK,NV>`	`toSortedMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)`
`MutableSortedSet<T>`	`toSortedSet()`
`MutableSortedSet<T>`	`toSortedSet(Comparator<? super T> comparator)`
`MutableStack<T>`	`toStack()`
`String`	`toString()`
`<S> MutableStack<Pair<T,S>>`	`zip(Iterable<S> that)`
`<S,R extends Collection<Pair<T,S>>> R`	`zip(Iterable<S> that, R target)`
`MutableStack<Pair<T,Integer>>`	`zipWithIndex()`
`<R extends Collection<Pair<T,Integer>>> R`	`zipWithIndex(R target)`

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

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

Methods inherited from interface java.lang.Iterable
spliterator

Methods inherited from interface org.eclipse.collections.api.stack.MutableStack
countBy, countByEach, countByWith, flatCollectWith

Constructor Detail

SynchronizedStack

public SynchronizedStack(MutableStack<T> newStack)

SynchronizedStack

public SynchronizedStack(MutableStack<T> newStack,
                         Object newLock)

Method Detail

of

public static <T,S extends MutableStack<T>> SynchronizedStack<T> of(S stack)

This method will take a MutableStack and wrap it directly in a SynchronizedStack.

pop
```
public T pop()
```
Specified by:

pop in interface MutableStack<T>

pop
```
public ListIterable<T> pop(int count)
```
Specified by:

pop in interface MutableStack<T>

pop

public <R extends Collection<T>> R pop(int count,
                                       R targetCollection)

Specified by:: pop in interface MutableStack<T>

pop

public <R extends MutableStack<T>> R pop(int count,
                                         R targetStack)

Specified by:: pop in interface MutableStack<T>

clear
```
public void clear()
```
Specified by:

clear in interface MutableStack<T>

push
```
public void push(T item)
```
Specified by:

push in interface MutableStack<T>

peek
```
public T peek()
```
Specified by:

peek in interface StackIterable<T>

peek
```
public ListIterable<T> peek(int count)
```
Specified by:

peek in interface StackIterable<T>

peekAt
```
public T peekAt(int index)
```
Specified by:

peekAt in interface StackIterable<T>

select
```
public MutableStack<T> select(Predicate<? super T> predicate)
```
Specified by:

select in interface MutableStack<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> MutableStack<T> selectWith(Predicate2<? super T,? super P> predicate,
                                      P parameter)
```
Specified by:

selectWith in interface MutableStack<T>

Specified by:

selectWith in interface OrderedIterable<T>

Specified by:

selectWith in interface RichIterable<T>

Specified by:

selectWith in interface StackIterable<T>

select

public <R extends Collection<T>> R select(Predicate<? super T> predicate,
                                          R target)

Specified by:: select in interface RichIterable<T>

selectWith

public <P,R extends Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate,
                                                      P parameter,
                                                      R targetCollection)

Specified by:: selectWith in interface RichIterable<T>

reject
```
public MutableStack<T> reject(Predicate<? super T> predicate)
```
Specified by:

reject in interface MutableStack<T>

Specified by:

reject in interface OrderedIterable<T>

Specified by:

reject in interface RichIterable<T>

Specified by:

reject in interface StackIterable<T>

rejectWith
```
public <P> MutableStack<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                      P parameter)
```
Specified by:

rejectWith in interface MutableStack<T>

Specified by:

rejectWith in interface OrderedIterable<T>

Specified by:

rejectWith in interface RichIterable<T>

Specified by:

rejectWith in interface StackIterable<T>

reject

public <R extends Collection<T>> R reject(Predicate<? super T> predicate,
                                          R target)

Specified by:: reject in interface RichIterable<T>

rejectWith

public <P,R extends Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate,
                                                      P parameter,
                                                      R targetCollection)

Specified by:: rejectWith in interface RichIterable<T>

partition
```
public PartitionMutableStack<T> partition(Predicate<? super T> predicate)
```
Specified by:

partition in interface MutableStack<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> PartitionMutableStack<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                  P parameter)
```
Specified by:

partitionWith in interface MutableStack<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> MutableStack<S> selectInstancesOf(Class<S> clazz)
```
Specified by:

selectInstancesOf in interface MutableStack<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> MutableStack<V> collect(Function<? super T,? extends V> function)
```
Specified by:

collect in interface MutableStack<T>

Specified by:

collect in interface OrderedIterable<T>

Specified by:

collect in interface RichIterable<T>

Specified by:

collect in interface StackIterable<T>

collectBoolean
```
public MutableBooleanStack collectBoolean(BooleanFunction<? super T> booleanFunction)
```
Specified by:

collectBoolean in interface MutableStack<T>

Specified by:

collectBoolean in interface OrderedIterable<T>

Specified by:

collectBoolean in interface RichIterable<T>

Specified by:

collectBoolean in interface StackIterable<T>

collectBoolean

public <R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction,
                                                             R target)

Specified by:: collectBoolean in interface RichIterable<T>

flatCollectBoolean

public <R extends MutableBooleanCollection> R flatCollectBoolean(Function<? super T,? extends BooleanIterable> function,
                                                                 R target)

Specified by:: flatCollectBoolean in interface RichIterable<T>

collectByte
```
public MutableByteStack collectByte(ByteFunction<? super T> byteFunction)
```
Specified by:

collectByte in interface MutableStack<T>

Specified by:

collectByte in interface OrderedIterable<T>

Specified by:

collectByte in interface RichIterable<T>

Specified by:

collectByte in interface StackIterable<T>

collectByte

public <R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction,
                                                       R target)

Specified by:: collectByte in interface RichIterable<T>

flatCollectByte

public <R extends MutableByteCollection> R flatCollectByte(Function<? super T,? extends ByteIterable> function,
                                                           R target)

Specified by:: flatCollectByte in interface RichIterable<T>

collectChar
```
public MutableCharStack collectChar(CharFunction<? super T> charFunction)
```
Specified by:

collectChar in interface MutableStack<T>

Specified by:

collectChar in interface OrderedIterable<T>

Specified by:

collectChar in interface RichIterable<T>

Specified by:

collectChar in interface StackIterable<T>

collectChar

public <R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction,
                                                       R target)

Specified by:: collectChar in interface RichIterable<T>

flatCollectChar

public <R extends MutableCharCollection> R flatCollectChar(Function<? super T,? extends CharIterable> function,
                                                           R target)

Specified by:: flatCollectChar in interface RichIterable<T>

collectDouble
```
public MutableDoubleStack collectDouble(DoubleFunction<? super T> doubleFunction)
```
Specified by:

collectDouble in interface MutableStack<T>

Specified by:

collectDouble in interface OrderedIterable<T>

Specified by:

collectDouble in interface RichIterable<T>

Specified by:

collectDouble in interface StackIterable<T>

collectDouble

public <R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction,
                                                           R target)

Specified by:: collectDouble in interface RichIterable<T>

flatCollectDouble

public <R extends MutableDoubleCollection> R flatCollectDouble(Function<? super T,? extends DoubleIterable> function,
                                                               R target)

Specified by:: flatCollectDouble in interface RichIterable<T>

collectFloat
```
public MutableFloatStack collectFloat(FloatFunction<? super T> floatFunction)
```
Specified by:

collectFloat in interface MutableStack<T>

Specified by:

collectFloat in interface OrderedIterable<T>

Specified by:

collectFloat in interface RichIterable<T>

Specified by:

collectFloat in interface StackIterable<T>

collectFloat

public <R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction,
                                                         R target)

Specified by:: collectFloat in interface RichIterable<T>

flatCollectFloat

public <R extends MutableFloatCollection> R flatCollectFloat(Function<? super T,? extends FloatIterable> function,
                                                             R target)

Specified by:: flatCollectFloat in interface RichIterable<T>

collectInt
```
public MutableIntStack collectInt(IntFunction<? super T> intFunction)
```
Specified by:

collectInt in interface MutableStack<T>

Specified by:

collectInt in interface OrderedIterable<T>

Specified by:

collectInt in interface RichIterable<T>

Specified by:

collectInt in interface StackIterable<T>

collectInt

public <R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction,
                                                     R target)

Specified by:: collectInt in interface RichIterable<T>

flatCollectInt

public <R extends MutableIntCollection> R flatCollectInt(Function<? super T,? extends IntIterable> function,
                                                         R target)

Specified by:: flatCollectInt in interface RichIterable<T>

collectLong
```
public MutableLongStack collectLong(LongFunction<? super T> longFunction)
```
Specified by:

collectLong in interface MutableStack<T>

Specified by:

collectLong in interface OrderedIterable<T>

Specified by:

collectLong in interface RichIterable<T>

Specified by:

collectLong in interface StackIterable<T>

flatCollectLong

public <R extends MutableLongCollection> R flatCollectLong(Function<? super T,? extends LongIterable> function,
                                                           R target)

Specified by:: flatCollectLong in interface RichIterable<T>

collectLong

public <R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction,
                                                       R target)

Specified by:: collectLong in interface RichIterable<T>

collectShort
```
public MutableShortStack collectShort(ShortFunction<? super T> shortFunction)
```
Specified by:

collectShort in interface MutableStack<T>

Specified by:

collectShort in interface OrderedIterable<T>

Specified by:

collectShort in interface RichIterable<T>

Specified by:

collectShort in interface StackIterable<T>

collectShort

public <R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction,
                                                         R target)

Specified by:: collectShort in interface RichIterable<T>

flatCollectShort

public <R extends MutableShortCollection> R flatCollectShort(Function<? super T,? extends ShortIterable> function,
                                                             R target)

Specified by:: flatCollectShort in interface RichIterable<T>

collect

public <V,R extends Collection<V>> R collect(Function<? super T,? extends V> function,
                                                   R target)

Specified by:: collect in interface RichIterable<T>

collectWith
```
public <P,V> MutableStack<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                               P parameter)
```
Specified by:

collectWith in interface MutableStack<T>

Specified by:

collectWith in interface OrderedIterable<T>

Specified by:

collectWith in interface RichIterable<T>

Specified by:

collectWith in interface StackIterable<T>

collectWith

public <P,V,R extends Collection<V>> R collectWith(Function2<? super T,? super P,? extends V> function,
                                                               P parameter,
                                                               R targetCollection)

Specified by:: collectWith in interface RichIterable<T>

collectIf
```
public <V> MutableStack<V> collectIf(Predicate<? super T> predicate,
                                     Function<? super T,? extends V> function)
```
Specified by:

collectIf in interface MutableStack<T>

Specified by:

collectIf in interface OrderedIterable<T>

Specified by:

collectIf in interface RichIterable<T>

Specified by:

collectIf in interface StackIterable<T>

collectIf

public <V,R extends Collection<V>> R collectIf(Predicate<? super T> predicate,
                                                     Function<? super T,? extends V> function,
                                                     R target)

Specified by:: collectIf in interface RichIterable<T>

flatCollect
```
public <V> MutableStack<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
```
Specified by:

flatCollect in interface MutableStack<T>

Specified by:

flatCollect in interface OrderedIterable<T>

Specified by:

flatCollect in interface RichIterable<T>

Specified by:

flatCollect in interface StackIterable<T>

flatCollect

public <V,R extends Collection<V>> R flatCollect(Function<? super T,? extends Iterable<V>> function,
                                                       R target)

Specified by:: flatCollect in interface RichIterable<T>

zip

public <S,R extends Collection<Pair<T,S>>> R zip(Iterable<S> that,
                                                             R target)

Specified by:: zip in interface OrderedIterable<T>
Specified by:: zip in interface RichIterable<T>

zip
```
public <S> MutableStack<Pair<T,S>> zip(Iterable<S> that)
```
Specified by:

zip in interface MutableStack<T>

Specified by:

zip in interface OrderedIterable<T>

Specified by:

zip in interface RichIterable<T>

Specified by:

zip in interface StackIterable<T>

zipWithIndex
```
public <R extends Collection<Pair<T,Integer>>> R zipWithIndex(R target)
```
Specified by:

zipWithIndex in interface OrderedIterable<T>

Specified by:

zipWithIndex in interface RichIterable<T>

zipWithIndex
```
public MutableStack<Pair<T,Integer>> zipWithIndex()
```
Specified by:

zipWithIndex in interface MutableStack<T>

Specified by:

zipWithIndex in interface OrderedIterable<T>

Specified by:

zipWithIndex in interface RichIterable<T>

Specified by:

zipWithIndex in interface StackIterable<T>

size
```
public int size()
```
Specified by:

size in interface RichIterable<T>

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface RichIterable<T>

notEmpty
```
public boolean notEmpty()
```
Specified by:

notEmpty in interface RichIterable<T>

getFirst
```
public T getFirst()
```
Specified by:

getFirst in interface OrderedIterable<T>

Specified by:

getFirst in interface RichIterable<T>

Specified by:

getFirst in interface StackIterable<T>

getFirstOptional
```
public Optional<T> getFirstOptional()
```
Specified by:

getFirstOptional in interface OrderedIterable<T>

getLast
```
public T getLast()
```
Specified by:

getLast in interface OrderedIterable<T>

Specified by:

getLast in interface RichIterable<T>

Specified by:

getLast in interface StackIterable<T>

getLastOptional
```
public Optional<T> getLastOptional()
```
Specified by:

getLastOptional in interface OrderedIterable<T>

getOnly
```
public T getOnly()
```
Specified by:

getOnly in interface RichIterable<T>

contains
```
public boolean contains(Object object)
```
Specified by:

contains in interface RichIterable<T>

containsAllIterable
```
public boolean containsAllIterable(Iterable<?> source)
```
Specified by:

containsAllIterable in interface RichIterable<T>

containsAll
```
public boolean containsAll(Collection<?> source)
```
Specified by:

containsAll in interface RichIterable<T>

containsAny
```
public boolean containsAny(Collection<?> source)
```
Specified by:

containsAny in interface RichIterable<T>

containsNone
```
public boolean containsNone(Collection<?> source)
```
Specified by:

containsNone in interface RichIterable<T>

containsAnyIterable
```
public boolean containsAnyIterable(Iterable<?> source)
```
Specified by:

containsAnyIterable in interface RichIterable<T>

containsNoneIterable
```
public boolean containsNoneIterable(Iterable<?> source)
```
Specified by:

containsNoneIterable in interface RichIterable<T>

containsAllArguments
```
public boolean containsAllArguments(Object... elements)
```
Specified by:

containsAllArguments in interface RichIterable<T>

detect

public T detect(Predicate<? super T> predicate)

Specified by:: detect in interface RichIterable<T>

detectWith

public <P> T detectWith(Predicate2<? super T,? super P> predicate,
                        P parameter)

Specified by:: detectWith in interface RichIterable<T>

detectOptional

public Optional<T> detectOptional(Predicate<? super T> predicate)

Specified by:: detectOptional in interface RichIterable<T>

detectWithOptional

public <P> Optional<T> detectWithOptional(Predicate2<? super T,? super P> predicate,
                                          P parameter)

Specified by:: detectWithOptional in interface RichIterable<T>

detectIfNone

public T detectIfNone(Predicate<? super T> predicate,
                      Function0<? extends T> function)

Specified by:: detectIfNone in interface RichIterable<T>

detectWithIfNone

public <P> T detectWithIfNone(Predicate2<? super T,? super P> predicate,
                              P parameter,
                              Function0<? extends T> function)

Specified by:: detectWithIfNone in interface RichIterable<T>

count

public int count(Predicate<? super T> predicate)

Specified by:: count in interface RichIterable<T>

countWith

public <P> int countWith(Predicate2<? super T,? super P> predicate,
                         P parameter)

Specified by:: countWith in interface RichIterable<T>

anySatisfy

public boolean anySatisfy(Predicate<? super T> predicate)

Specified by:: anySatisfy in interface RichIterable<T>

anySatisfyWith

public <P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)

Specified by:: anySatisfyWith in interface RichIterable<T>

allSatisfy

public boolean allSatisfy(Predicate<? super T> predicate)

Specified by:: allSatisfy in interface RichIterable<T>

allSatisfyWith

public <P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)

Specified by:: allSatisfyWith in interface RichIterable<T>

noneSatisfy

public boolean noneSatisfy(Predicate<? super T> predicate)

Specified by:: noneSatisfy in interface RichIterable<T>

noneSatisfyWith

public <P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate,
                                   P parameter)

Specified by:: noneSatisfyWith in interface RichIterable<T>

injectInto

public <IV> IV injectInto(IV injectedValue,
                          Function2<? super IV,? super T,? extends IV> function)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public int injectInto(int injectedValue,
                      IntObjectToIntFunction<? super T> intObjectToIntFunction)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public long injectInto(long injectedValue,
                       LongObjectToLongFunction<? super T> longObjectToLongFunction)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public float injectInto(float injectedValue,
                        FloatObjectToFloatFunction<? super T> floatObjectToFloatFunction)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public double injectInto(double injectedValue,
                         DoubleObjectToDoubleFunction<? super T> doubleObjectToDoubleFunction)

Specified by:: injectInto in interface RichIterable<T>

into

public <R extends Collection<T>> R into(R target)

Specified by:: into in interface RichIterable<T>

toList
```
public MutableList<T> toList()
```
Specified by:

toList in interface RichIterable<T>

toSortedList
```
public MutableList<T> toSortedList()
```
Specified by:

toSortedList in interface RichIterable<T>

toSortedList

public MutableList<T> toSortedList(Comparator<? super T> comparator)

Specified by:: toSortedList in interface RichIterable<T>

toSet
```
public MutableSet<T> toSet()
```
Specified by:

toSet in interface RichIterable<T>

toSortedSet
```
public MutableSortedSet<T> toSortedSet()
```
Specified by:

toSortedSet in interface RichIterable<T>

toSortedSet

public MutableSortedSet<T> toSortedSet(Comparator<? super T> comparator)

Specified by:: toSortedSet in interface RichIterable<T>

toStack
```
public MutableStack<T> toStack()
```
Specified by:

toStack in interface OrderedIterable<T>

Specified by:

toStack in interface StackIterable<T>

toImmutable
```
public ImmutableStack<T> toImmutable()
```
Specified by:

toImmutable in interface StackIterable<T>

toBag
```
public MutableBag<T> toBag()
```
Specified by:

toBag in interface RichIterable<T>

toSortedBag
```
public MutableSortedBag<T> toSortedBag()
```
Specified by:

toSortedBag in interface RichIterable<T>

toSortedBag

public MutableSortedBag<T> toSortedBag(Comparator<? super T> comparator)

Specified by:: toSortedBag in interface RichIterable<T>

toMap

public <NK,NV> MutableMap<NK,NV> toMap(Function<? super T,? extends NK> keyFunction,
                                                   Function<? super T,? extends NV> valueFunction)

Specified by:: toMap in interface RichIterable<T>

toMap

public <NK,NV,R extends Map<NK,NV>> R toMap(Function<? super T,? extends NK> keyFunction,
                                                              Function<? super T,? extends NV> valueFunction,
                                                              R target)

Specified by:: toMap in interface RichIterable<T>

toSortedMap

public <NK,NV> MutableSortedMap<NK,NV> toSortedMap(Function<? super T,? extends NK> keyFunction,
                                                               Function<? super T,? extends NV> valueFunction)

Specified by:: toSortedMap in interface RichIterable<T>

toSortedMap

public <NK,NV> MutableSortedMap<NK,NV> toSortedMap(Comparator<? super NK> comparator,
                                                               Function<? super T,? extends NK> keyFunction,
                                                               Function<? super T,? extends NV> valueFunction)

Specified by:: toSortedMap in interface RichIterable<T>

toBiMap

public <NK,NV> MutableBiMap<NK,NV> toBiMap(Function<? super T,? extends NK> keyFunction,
                                                       Function<? super T,? extends NV> valueFunction)

Specified by:: toBiMap in interface RichIterable<T>

asLazy
```
public LazyIterable<T> asLazy()
```
Specified by:

asLazy in interface RichIterable<T>

toArray
```
public Object[] toArray()
```
Specified by:

toArray in interface RichIterable<T>

toArray
```
public <T> T[] toArray(T[] a)
```
Specified by:

toArray in interface RichIterable<T>

min

public T min(Comparator<? super T> comparator)

Specified by:: min in interface RichIterable<T>

max

public T max(Comparator<? super T> comparator)

Specified by:: max in interface RichIterable<T>

min
```
public T min()
```
Specified by:

min in interface OrderedIterable<T>

Specified by:

min in interface RichIterable<T>

max
```
public T max()
```
Specified by:

max in interface OrderedIterable<T>

Specified by:

max in interface RichIterable<T>

minBy

public <V extends Comparable<? super V>> T minBy(Function<? super T,? extends V> function)

Specified by:: minBy in interface RichIterable<T>

maxBy

public <V extends Comparable<? super V>> T maxBy(Function<? super T,? extends V> function)

Specified by:: maxBy in interface RichIterable<T>

sumOfInt

public long sumOfInt(IntFunction<? super T> intFunction)

Specified by:: sumOfInt in interface RichIterable<T>

sumOfFloat

public double sumOfFloat(FloatFunction<? super T> floatFunction)

Specified by:: sumOfFloat in interface RichIterable<T>

sumOfLong

public long sumOfLong(LongFunction<? super T> longFunction)

Specified by:: sumOfLong in interface RichIterable<T>

sumOfDouble

public double sumOfDouble(DoubleFunction<? super T> doubleFunction)

Specified by:: sumOfDouble in interface RichIterable<T>

sumByInt

public <V> MutableObjectLongMap<V> sumByInt(Function<? super T,? extends V> groupBy,
                                            IntFunction<? super T> function)

Specified by:: sumByInt in interface MutableStack<T>
Specified by:: sumByInt in interface RichIterable<T>

sumByFloat

public <V> MutableObjectDoubleMap<V> sumByFloat(Function<? super T,? extends V> groupBy,
                                                FloatFunction<? super T> function)

Specified by:: sumByFloat in interface MutableStack<T>
Specified by:: sumByFloat in interface RichIterable<T>

sumByLong

public <V> MutableObjectLongMap<V> sumByLong(Function<? super T,? extends V> groupBy,
                                             LongFunction<? super T> function)

Specified by:: sumByLong in interface MutableStack<T>
Specified by:: sumByLong in interface RichIterable<T>

sumByDouble

public <V> MutableObjectDoubleMap<V> sumByDouble(Function<? super T,? extends V> groupBy,
                                                 DoubleFunction<? super T> function)

Specified by:: sumByDouble in interface MutableStack<T>
Specified by:: sumByDouble in interface RichIterable<T>

makeString
```
public String makeString()
```
Specified by:

makeString in interface RichIterable<T>

makeString
```
public String makeString(String separator)
```
Specified by:

makeString in interface RichIterable<T>

makeString

public String makeString(String start,
                         String separator,
                         String end)

Specified by:: makeString in interface RichIterable<T>

appendString
```
public void appendString(Appendable appendable)
```
Specified by:

appendString in interface RichIterable<T>

appendString

public void appendString(Appendable appendable,
                         String separator)

Specified by:: appendString in interface RichIterable<T>

appendString

public void appendString(Appendable appendable,
                         String start,
                         String separator,
                         String end)

Specified by:: appendString in interface RichIterable<T>

groupBy
```
public <V> MutableListMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
Specified by:

groupBy in interface MutableStack<T>

Specified by:

groupBy in interface OrderedIterable<T>

Specified by:

groupBy in interface RichIterable<T>

Specified by:

groupBy in interface StackIterable<T>

groupBy

public <V,R extends MutableMultimap<V,T>> R groupBy(Function<? super T,? extends V> function,
                                                                R target)

Specified by:: groupBy in interface RichIterable<T>

groupByEach
```
public <V> MutableListMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
Specified by:

groupByEach in interface MutableStack<T>

Specified by:

groupByEach in interface OrderedIterable<T>

Specified by:

groupByEach in interface RichIterable<T>

Specified by:

groupByEach in interface StackIterable<T>

groupByEach

public <V,R extends MutableMultimap<V,T>> R groupByEach(Function<? super T,? extends Iterable<V>> function,
                                                                    R target)

Specified by:: groupByEach in interface RichIterable<T>

groupByUniqueKey
```
public <V> MutableMap<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
```
Specified by:

groupByUniqueKey in interface MutableStack<T>

Specified by:

groupByUniqueKey in interface RichIterable<T>

groupByUniqueKey

public <V,R extends MutableMapIterable<V,T>> R groupByUniqueKey(Function<? super T,? extends V> function,
                                                                            R target)

Specified by:: groupByUniqueKey in interface RichIterable<T>

chunk

public RichIterable<RichIterable<T>> chunk(int size)

Specified by:: chunk in interface RichIterable<T>

tap
```
public MutableStack<T> tap(Procedure<? super T> procedure)
```
Specified by:

tap in interface MutableStack<T>

Specified by:

tap in interface OrderedIterable<T>

Specified by:

tap in interface RichIterable<T>

Specified by:

tap in interface StackIterable<T>

each

public void each(Procedure<? super T> procedure)

Specified by:: each in interface RichIterable<T>

toString
```
public String toString()
```
Specified by:

toString in interface RichIterable<T>

Specified by:

toString in interface StackIterable<T>

Overrides:

toString in class Object

forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
```
Specified by:

forEachWithIndex in interface InternalIterable<T>

Specified by:

forEachWithIndex in interface OrderedIterable<T>

forEachWith

public <P> void forEachWith(Procedure2<? super T,? super P> procedure,
                            P parameter)

Specified by:: forEachWith in interface InternalIterable<T>

asUnmodifiable
```
public MutableStack<T> asUnmodifiable()
```
Specified by:

asUnmodifiable in interface MutableStack<T>

equals
```
public boolean equals(Object obj)
```
Specified by:

equals in interface StackIterable<T>

Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Specified by:

hashCode in interface StackIterable<T>

Overrides:

hashCode in class Object

asSynchronized
```
public MutableStack<T> asSynchronized()
```
Specified by:

asSynchronized in interface MutableStack<T>

iterator
```
public Iterator<T> iterator()
```
Specified by:

iterator in interface Iterable<T>

aggregateInPlaceBy

public <K,V> MutableMap<K,V> aggregateInPlaceBy(Function<? super T,? extends K> groupBy,
                                                            Function0<? extends V> zeroValueFactory,
                                                            Procedure2<? super V,? super T> mutatingAggregator)

Specified by:: aggregateInPlaceBy in interface MutableStack<T>
Specified by:: aggregateInPlaceBy in interface RichIterable<T>

aggregateBy

public <K,V> MutableMap<K,V> aggregateBy(Function<? super T,? extends K> groupBy,
                                                     Function0<? extends V> zeroValueFactory,
                                                     Function2<? super V,? super T,? extends V> nonMutatingAggregator)

Specified by:: aggregateBy in interface MutableStack<T>
Specified by:: aggregateBy in interface RichIterable<T>

takeWhile
```
public MutableStack<T> takeWhile(Predicate<? super T> predicate)
```
Specified by:

takeWhile in interface MutableStack<T>

Specified by:

takeWhile in interface OrderedIterable<T>

Specified by:

takeWhile in interface StackIterable<T>

dropWhile
```
public MutableStack<T> dropWhile(Predicate<? super T> predicate)
```
Specified by:

dropWhile in interface MutableStack<T>

Specified by:

dropWhile in interface OrderedIterable<T>

Specified by:

dropWhile in interface StackIterable<T>

partitionWhile
```
public PartitionMutableStack<T> partitionWhile(Predicate<? super T> predicate)
```
Specified by:

partitionWhile in interface MutableStack<T>

Specified by:

partitionWhile in interface OrderedIterable<T>

Specified by:

partitionWhile in interface StackIterable<T>

distinct
```
public MutableStack<T> distinct()
```
Specified by:

distinct in interface MutableStack<T>

Specified by:

distinct in interface OrderedIterable<T>

Specified by:

distinct in interface StackIterable<T>

collectWithIndex
```
public <V> MutableStack<V> collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function)
```
Specified by:

collectWithIndex in interface MutableStack<T>

Specified by:

collectWithIndex in interface OrderedIterable<T>

Specified by:

collectWithIndex in interface StackIterable<T>

collectWithIndex

public <V,R extends Collection<V>> R collectWithIndex(ObjectIntToObjectFunction<? super T,? extends V> function,
                                                            R target)

Specified by:: collectWithIndex in interface OrderedIterable<T>
Since:: 9.1

selectWithIndex

public <R extends Collection<T>> R selectWithIndex(ObjectIntPredicate<? super T> predicate,
                                                   R target)

Specified by:: selectWithIndex in interface OrderedIterable<T>
Since:: 11.0

rejectWithIndex

public <R extends Collection<T>> R rejectWithIndex(ObjectIntPredicate<? super T> predicate,
                                                   R target)

Specified by:: rejectWithIndex in interface OrderedIterable<T>
Since:: 11.0

indexOf
```
public int indexOf(Object object)
```
Specified by:

indexOf in interface OrderedIterable<T>

corresponds

public <S> boolean corresponds(OrderedIterable<S> other,
                               Predicate2<? super T,? super S> predicate)

Specified by:: corresponds in interface OrderedIterable<T>

forEach

public void forEach(int startIndex,
                    int endIndex,
                    Procedure<? super T> procedure)

Specified by:: forEach in interface OrderedIterable<T>

forEachWithIndex

public void forEachWithIndex(int fromIndex,
                             int toIndex,
                             ObjectIntProcedure<? super T> objectIntProcedure)

Specified by:: forEachWithIndex in interface OrderedIterable<T>

detectIndex
```
public int detectIndex(Predicate<? super T> predicate)
```
Specified by:

detectIndex in interface OrderedIterable<T>

Constructor	Description
`SynchronizedStack(MutableStack<T> newStack)`
`SynchronizedStack(MutableStack<T> newStack, Object newLock)`

Class SynchronizedStack<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.Iterable

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

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

Constructor Detail

SynchronizedStack

SynchronizedStack

Method Detail

of

pop

pop

pop

pop

clear

push

peek

peek

peekAt

select

selectWith

select

selectWith

reject

rejectWith

reject

rejectWith

partition

partitionWith

selectInstancesOf

collect

collectBoolean

collectBoolean

flatCollectBoolean

collectByte

collectByte

flatCollectByte

collectChar

collectChar

flatCollectChar

collectDouble

collectDouble

flatCollectDouble

collectFloat

collectFloat

flatCollectFloat

collectInt

collectInt

flatCollectInt

collectLong

flatCollectLong

collectLong

collectShort

collectShort

flatCollectShort

collect

collectWith

collectWith

collectIf

collectIf

flatCollect

flatCollect

zip

zip

zipWithIndex

zipWithIndex

size

isEmpty

notEmpty

getFirst

getFirstOptional

getLast

getLastOptional

getOnly

contains

containsAllIterable

containsAll