FixedSizeCollection (Goldman Sachs Collections API

All Superinterfaces:

java.util.Collection<T>, InternalIterable<T>, java.lang.Iterable<T>, MutableCollection<T>, RichIterable<T>

All Known Subinterfaces:

FixedSizeList<T>, FixedSizeSet<T>
```
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

Methods
Modifier and Type	Method and 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)`
`void`	`removeIf(Predicate<? super T> predicate)` Removes all elements in the collection that evaluate to true for the specified predicate.
`<P> void`	`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)`
`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 com.gs.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, toImmutable, zip, zipWithIndex

Methods inherited from interface java.util.Collection
contains, containsAll, equals, hashCode, isEmpty, iterator, size, toArray, toArray

Methods inherited from interface com.gs.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, flatCollect, getFirst, getLast, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from interface com.gs.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex

- 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(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 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 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
```
void 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> void 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:
    
    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

Interface FixedSizeCollection<T>

Method Summary

Methods inherited from interface com.gs.collections.api.collection.MutableCollection

Methods inherited from interface java.util.Collection

Methods inherited from interface com.gs.collections.api.RichIterable

Methods inherited from interface com.gs.collections.api.InternalIterable

Method Detail

with

without

withAll

withoutAll

add

addAllIterable

addAll

remove

removeAll

removeAllIterable

removeIf

removeIfWith

retainAll

retainAllIterable

clear