public interface FixedSizeCollection<T> extends MutableCollection<T>
| 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) |
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.
|
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, zipWithIndexcontains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, removeIf, size, spliterator, stream, toArray, toArrayallSatisfy, 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, zipWithIndexforEach, forEach, forEachWith, forEachWithIndexMutableCollection<T> with(T element)
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;
with in interface MutableCollection<T>add(Object)MutableCollection<T> without(T element)
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;
without in interface MutableCollection<T>remove(Object)MutableCollection<T> withAll(Iterable<? extends T> elements)
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;
withAll in interface MutableCollection<T>addAll(Collection)MutableCollection<T> withoutAll(Iterable<? extends T> elements)
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;
withoutAll in interface MutableCollection<T>removeAll(Collection)boolean add(T t)
add in interface Collection<T>UnsupportedOperationExceptionboolean addAllIterable(Iterable<? extends T> iterable)
addAllIterable in interface MutableCollection<T>UnsupportedOperationExceptionCollection.addAll(Collection)boolean addAll(Collection<? extends T> collection)
addAll in interface Collection<T>UnsupportedOperationExceptionboolean remove(Object o)
remove in interface Collection<T>UnsupportedOperationExceptionboolean removeAll(Collection<?> collection)
removeAll in interface Collection<T>UnsupportedOperationExceptionboolean removeAllIterable(Iterable<?> iterable)
removeAllIterable in interface MutableCollection<T>UnsupportedOperationExceptionCollection.removeAll(Collection)boolean removeIf(Predicate<? super T> predicate)
MutableCollection
e.g. return lastNames.removeIf(Predicates.isNull());
removeIf in interface MutableCollection<T>UnsupportedOperationException<P> boolean removeIfWith(Predicate2<? super T,? super P> predicate, P parameter)
MutableCollection
return lastNames.removeIfWith(Predicates2.isNull(), null);
removeIfWith in interface MutableCollection<T>UnsupportedOperationExceptionboolean retainAll(Collection<?> collection)
retainAll in interface Collection<T>UnsupportedOperationExceptionboolean retainAllIterable(Iterable<?> iterable)
retainAllIterable in interface MutableCollection<T>UnsupportedOperationExceptionCollection.retainAll(Collection)void clear()
clear in interface Collection<T>UnsupportedOperationExceptionFixedSizeCollection<T> tap(Procedure<? super T> procedure)
RichIterablethis.
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());
}
});
tap in interface MutableCollection<T>tap in interface RichIterable<T>RichIterable.each(Procedure),
InternalIterable.forEach(Procedure)Copyright © 2004–2017. All rights reserved.