FixedSizeCollection (Eclipse Collections

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

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and 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)`
`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 org.eclipse.collections.api.collection.MutableCollection
aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, flatCollect, groupBy, groupByEach, groupByUniqueKey, injectIntoWith, newEmpty, partition, partitionWith, reject, rejectWith, select, selectAndRejectWith, selectInstancesOf, selectWith, tap, toImmutable, zip, zipWithIndex

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.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, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

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

Methods inherited from interface java.lang.Iterable
forEach

- 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 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 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 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 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
  - addAllIterable
```
boolean addAllIterable(Iterable<? extends T> iterable)
```
    Specified by:
    
    addAllIterable in interface MutableCollection<T>
    
    Throws:
    
    UnsupportedOperationException
    
    See Also:
    
    Collection.addAll(Collection)
  - addAll
```
boolean addAll(Collection<? extends T> collection)
```
    Specified by:
    
    addAll in interface Collection<T>
    
    Throws:
    
    UnsupportedOperationException
  - remove
```
boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<T>
    
    Throws:
    
    UnsupportedOperationException
  - removeAll
```
boolean removeAll(Collection<?> collection)
```
    Specified by:
    
    removeAll in interface Collection<T>
    
    Throws:
    
    UnsupportedOperationException
  - removeAllIterable
```
boolean removeAllIterable(Iterable<?> iterable)
```
    Specified by:
    
    removeAllIterable in interface MutableCollection<T>
    
    Throws:
    
    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:
    
    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.
```
e.g.
 return lastNames.removeIfWith(PredicatesLite.isNull(), null);
 
```
    Specified by:
    
    removeIfWith in interface MutableCollection<T>
    
    Throws:
    
    UnsupportedOperationException
  - retainAll
```
boolean retainAll(Collection<?> collection)
```
    Specified by:
    
    retainAll in interface Collection<T>
    
    Throws:
    
    UnsupportedOperationException
  - retainAllIterable
```
boolean retainAllIterable(Iterable<?> iterable)
```
    Specified by:
    
    retainAllIterable in interface MutableCollection<T>
    
    Throws:
    
    UnsupportedOperationException
    
    See Also:
    
    Collection.retainAll(Collection)
  - clear
```
void clear()
```
    Specified by:
    
    clear in interface Collection<T>
    
    Throws:
    
    UnsupportedOperationException

Interface FixedSizeCollection<T>

Method Summary

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

Methods inherited from interface java.util.Collection

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

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

Methods inherited from interface java.lang.Iterable

Method Detail

with

without

withAll

withoutAll

add

addAllIterable

addAll

remove

removeAll

removeAllIterable

removeIf

removeIfWith

retainAll

retainAllIterable

clear