Package org.eclipse.collections.api.collection

Interface FixedSizeCollection<T>

All Superinterfaces:

Collection<T>, InternalIterable<T>, Iterable<T>, MutableCollection<T>, RichIterable<T>

All Known Subinterfaces:

FixedSizeList<T>, FixedSizeSet<T>

All Known Implementing Classes:

AbstractMemoryEfficientMutableList, ArrayAdapter

public interface FixedSizeCollection<T>
extends MutableCollection<T>

A FixedSizeCollection is a collection that may be mutated, but cannot grow or shrink in size. It is up to the underlying implementation to decide which mutations are allowable.

Method Summary

Modifier and Type	Method	Description
boolean	add(T t)
boolean	addAll(Collection<? extends T> collection)
boolean	addAllIterable(Iterable<? extends T> iterable)
void	clear()
boolean	remove(Object o)
boolean	removeAll(Collection<?> collection)
boolean	removeAllIterable(Iterable<?> iterable)
boolean	removeIf(Predicate<? super T> predicate)	Removes all elements in the collection that evaluate to true for the specified predicate.
<P> boolean	removeIfWith(Predicate2<? super T,? super P> predicate, P parameter)	Removes all elements in the collection that evaluate to true for the specified predicate2 and parameter.
boolean	retainAll(Collection<?> collection)
boolean	retainAllIterable(Iterable<?> iterable)
FixedSizeCollection<T>	tap(Procedure<? super T> procedure)	Executes the Procedure for each element in the iterable and returns this.
MutableCollection<T>	with(T element)	This method allows fixed size collections the ability to add elements to their existing elements.
MutableCollection<T>	withAll(Iterable<? extends T> elements)	This method allows fixed size collections the ability to add multiple elements to their existing elements.
MutableCollection<T>	without(T element)	This method allows fixed size collections the ability to remove elements from their existing elements.
MutableCollection<T>	withoutAll(Iterable<? extends T> elements)	This method allows fixed size collections the ability to remove multiple elements from their existing elements.

Methods inherited from interface java.util.Collection

contains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, removeIf, size, spliterator, stream, toArray, toArray, toArray

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

forEach, forEachWith, forEachWithIndex

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection

aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, countBy, countByEach, countByWith, flatCollect, flatCollectWith, groupBy, groupByEach, groupByUniqueKey, injectIntoWith, newEmpty, partition, partitionWith, reject, rejectWith, select, selectAndRejectWith, selectInstancesOf, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, toImmutable, zip, zipWithIndex

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

aggregateBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsBy, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, size, 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, toString, zip, zipWithIndex

Method Details

with

MutableCollection<T> with(T element)

This method allows fixed size collections the ability to add elements to their existing elements. A new instance of MutableCollection is returned containing the elements of the original collection with the new element added. Implementations will return a new FixedSizeCollection where possible. In order to use this method properly with mutable and fixed size collections the following approach must be taken:

 MutableCollection<String> list;
 list = list.with("1");
 list = list.with("2");
 return list;
 

Specified by:

with in interface MutableCollection<T>

See Also:

• add(Object)

without

MutableCollection<T> without(T element)

This method allows fixed size collections the ability to remove elements from their existing elements. A new instance of MutableCollection is returned containing the elements of the original collection with the element removed. Implementations will return a new FixedSizeCollection where possible. In order to use this method properly with mutable and fixed size collections the following approach must be taken:

 MutableCollection<String> list;
 list = list.without("1");
 list = list.without("2");
 return list;
 

Specified by:

without in interface MutableCollection<T>

See Also:

• remove(Object)

withAll

MutableCollection<T> withAll(Iterable<? extends T> elements)

This method allows fixed size collections the ability to add multiple elements to their existing elements. A new instance of MutableCollection is returned containing the elements of the original collection with all of the new elements added. Implementations will return a new FixedSizeCollection where possible. In order to use this method properly with mutable and fixed size collections the following approach must be taken:

 MutableCollection<String> list;
 list = list.withAll(FastList.newListWith("1", "2"));
 return list;
 

Specified by:

withAll in interface MutableCollection<T>

See Also:

• addAll(Collection)

withoutAll

MutableCollection<T> withoutAll(Iterable<? extends T> elements)

This method allows fixed size collections the ability to remove multiple elements from their existing elements. A new instance of MutableCollection is returned containing the elements of the original collection with the given elements removed. Implementations will return a new FixedSizeCollection where possible. In order to use this method properly with mutable and fixed size collections the following approach must be taken:

 MutableCollection<String> list;
 list = list.withoutAll(FastList.newListWith("1", "2"));
 return list;
 

Specified by:

withoutAll in interface MutableCollection<T>

See Also:

• removeAll(Collection)

add

boolean add(T t)

Specified by:

add in interface Collection<T>

Throws:

UnsupportedOperationException - the add operation is not supported by this collection.

addAllIterable

boolean addAllIterable(Iterable<? extends T> iterable)

Specified by:

addAllIterable in interface MutableCollection<T>

Throws:

UnsupportedOperationException - the addAllIterable operation is not supported by this collection.

See Also:

• Collection.addAll(Collection)

addAll

boolean addAll(Collection<? extends T> collection)

Specified by:

addAll in interface Collection<T>

Throws:

UnsupportedOperationException - the addAll operation is not supported by this collection.

remove

boolean remove(Object o)

Specified by:

remove in interface Collection<T>

Throws:

UnsupportedOperationException - the remove operation is not supported by this collection.

removeAll

boolean removeAll(Collection<?> collection)

Specified by:

removeAll in interface Collection<T>

Throws:

UnsupportedOperationException - the removeAll method is not supported by this collection.

removeAllIterable

boolean removeAllIterable(Iterable<?> iterable)

Specified by:

removeAllIterable in interface MutableCollection<T>

Throws:

UnsupportedOperationException - the removeAllIterable method is not supported by this collection.

See Also:

• Collection.removeAll(Collection)

removeIf

boolean removeIf(Predicate<? super T> predicate)

Description copied from interface: MutableCollection

Removes all elements in the collection that evaluate to true for the specified predicate.

e.g.
 return lastNames.removeIf(Predicates.isNull());
 

Specified by:

removeIf in interface MutableCollection<T>

Throws:

UnsupportedOperationException - the removeIf method is not supported by this collection.

removeIfWith

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

Description copied from interface: MutableCollection

Removes all elements in the collection that evaluate to true for the specified predicate2 and parameter.

 return lastNames.removeIfWith(Predicates2.isNull(), null);
 

Specified by:

removeIfWith in interface MutableCollection<T>

Throws:

UnsupportedOperationException - the removeIfWith method is not supported by this collection.

retainAll

boolean retainAll(Collection<?> collection)

Specified by:

retainAll in interface Collection<T>

Throws:

UnsupportedOperationException - the retainAll method is not supported by this collection.

retainAllIterable

boolean retainAllIterable(Iterable<?> iterable)

Specified by:

retainAllIterable in interface MutableCollection<T>

Throws:

UnsupportedOperationException - the retainAllIterable method is not supported by this collection.

See Also:

• Collection.retainAll(Collection)

clear

void clear()

Specified by:

clear in interface Collection<T>

Throws:

UnsupportedOperationException - the clear method is not supported by this collection.

tap

FixedSizeCollection<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()));
 

Example using an anonymous inner class:

 RichIterable<Person> tapped =
     people.tap(new Procedure<Person>()
     {
         public void value(Person person)
         {
             LOGGER.info(person.getName());
         }
     });
 

Specified by:

tap in interface MutableCollection<T>

Specified by:

tap in interface RichIterable<T>

See Also:

• RichIterable.each(Procedure)
• RichIterable.forEach(Procedure)