Package org.eclipse.collections.api.collection

Interface FixedSizeCollection<T>

All Superinterfaces:

java.util.Collection<T>, InternalIterable<T>, java.lang.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(java.util.Collection<? extends T> collection)
boolean	addAllIterable(java.lang.Iterable<? extends T> iterable)
void	clear()
boolean	remove(java.lang.Object o)
boolean	removeAll(java.util.Collection<?> collection)
boolean	removeAllIterable(java.lang.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(java.util.Collection<?> collection)
boolean	retainAllIterable(java.lang.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(java.lang.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(java.lang.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

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

forEach, 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, countByWith, flatCollect, 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

allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countBy, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, getFirst, getLast, getOnly, groupBy, 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, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

Method Detail

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(java.lang.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(java.lang.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 java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

addAllIterable

boolean addAllIterable(java.lang.Iterable<? extends T> iterable)

Specified by:

addAllIterable in interface MutableCollection<T>

Throws:

java.lang.UnsupportedOperationException

See Also:

Collection.addAll(Collection)

addAll

boolean addAll(java.util.Collection<? extends T> collection)

Specified by:

addAll in interface java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

remove

boolean remove(java.lang.Object o)

Specified by:

remove in interface java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

removeAll

boolean removeAll(java.util.Collection<?> collection)

Specified by:

removeAll in interface java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

removeAllIterable

boolean removeAllIterable(java.lang.Iterable<?> iterable)

Specified by:

removeAllIterable in interface MutableCollection<T>

Throws:

java.lang.UnsupportedOperationException

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:

java.lang.UnsupportedOperationException

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:

java.lang.UnsupportedOperationException

retainAll

boolean retainAll(java.util.Collection<?> collection)

Specified by:

retainAll in interface java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

retainAllIterable

boolean retainAllIterable(java.lang.Iterable<?> iterable)

Specified by:

retainAllIterable in interface MutableCollection<T>

Throws:

java.lang.UnsupportedOperationException

See Also:

Collection.retainAll(Collection)

clear

void clear()

Specified by:

clear in interface java.util.Collection<T>

Throws:

java.lang.UnsupportedOperationException

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), InternalIterable.forEach(Procedure)