java.lang.Cloneable
, java.lang.Iterable<T>
, java.util.Collection<T>
, java.util.Set<T>
, MutableCollection<T>
, InternalIterable<T>
, RichIterable<T>
, MutableSet<T>
, MutableSetIterable<T>
, Pool<T>
, SetIterable<T>
, UnsortedSetIterable<T>
, BatchIterable<T>
UnifiedSet
, UnifiedSetWithHashingStrategy
public abstract class AbstractUnifiedSet<T> extends AbstractMutableCollection<T> implements MutableSet<T>, Pool<T>, BatchIterable<T>
Constructor | Description |
---|---|
AbstractUnifiedSet() |
Modifier and Type | Method | Description |
---|---|---|
boolean |
allSatisfy(Predicate<? super T> predicate) |
Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty.
|
<P> boolean |
allSatisfyWith(Predicate2<? super T,? super P> predicate,
P parameter) |
Returns true if the predicate evaluates to true for every element of the collection, or returns false.
|
boolean |
anySatisfy(Predicate<? super T> predicate) |
Returns true if the predicate evaluates to true for any element of the iterable.
|
<P> boolean |
anySatisfyWith(Predicate2<? super T,? super P> predicate,
P parameter) |
Returns true if the predicate evaluates to true for any element of the collection, or return false.
|
MutableSet<T> |
asSynchronized() |
Returns a synchronized wrapper backed by this collection.
|
MutableSet<T> |
asUnmodifiable() |
Returns an unmodifiable view of the set.
|
<B> LazyIterable<Pair<T,B>> |
cartesianProduct(SetIterable<B> set) |
Returns the set whose members are all possible ordered pairs (a, b) where a is a member of
this and b is a
member of set . |
RichIterable<RichIterable<T>> |
chunk(int size) |
Partitions elements in fixed size chunks.
|
abstract MutableSet<T> |
clone() |
|
<V> UnifiedSet<V> |
collect(Function<? super T,? extends V> function) |
Returns a new collection with the results of applying the specified function on each element of the source
collection.
|
MutableBooleanSet |
collectBoolean(BooleanFunction<? super T> booleanFunction) |
Returns a new primitive
boolean iterable with the results of applying the specified function on each element
of the source collection. |
MutableByteSet |
collectByte(ByteFunction<? super T> byteFunction) |
Returns a new primitive
byte iterable with the results of applying the specified function on each element
of the source collection. |
MutableCharSet |
collectChar(CharFunction<? super T> charFunction) |
Returns a new primitive
char iterable with the results of applying the specified function on each element
of the source collection. |
MutableDoubleSet |
collectDouble(DoubleFunction<? super T> doubleFunction) |
Returns a new primitive
double iterable with the results of applying the specified function on each element
of the source collection. |
MutableFloatSet |
collectFloat(FloatFunction<? super T> floatFunction) |
Returns a new primitive
float iterable with the results of applying the specified function on each element
of the source collection. |
<V> UnifiedSet<V> |
collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
Returns a new collection with the results of applying the specified function on each element of the source
collection, but only for those elements which return true upon evaluation of the predicate.
|
MutableIntSet |
collectInt(IntFunction<? super T> intFunction) |
Returns a new primitive
int iterable with the results of applying the specified function on each element
of the source collection. |
MutableLongSet |
collectLong(LongFunction<? super T> longFunction) |
Returns a new primitive
long iterable with the results of applying the specified function on each element
of the source collection. |
MutableShortSet |
collectShort(ShortFunction<? super T> shortFunction) |
Returns a new primitive
short iterable with the results of applying the specified function on each element
of the source collection. |
<P,A> UnifiedSet<A> |
collectWith(Function2<? super T,? super P,? extends A> function,
P parameter) |
Same as
RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block. |
T |
detect(Predicate<? super T> predicate) |
Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no
element returns true.
|
java.util.Optional<T> |
detectOptional(Predicate<? super T> predicate) |
Returns the first element of the iterable for which the predicate evaluates to true as an Optional.
|
MutableSet<T> |
difference(SetIterable<? extends T> subtrahendSet) |
Returns the set of all members of
this that are not members of subtrahendSet . |
<R extends java.util.Set<T>> |
differenceInto(SetIterable<? extends T> subtrahendSet,
R targetSet) |
Same as
SetIterable.difference(SetIterable) but adds all the objects to targetSet and returns it. |
<V> UnifiedSet<V> |
flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
flatCollect is a special case of RichIterable.collect(Function) . |
int |
getBatchCount(int batchSize) |
|
<V> MutableMap<V,T> |
groupByUniqueKey(Function<? super T,? extends V> function) |
For each element of the iterable, the function is evaluated and he results of these evaluations are collected
into a new map, where the transformed value is the key.
|
<IV,P> IV |
injectIntoWith(IV injectValue,
Function3<? super IV,? super T,? super P,? extends IV> function,
P parameter) |
|
MutableSet<T> |
intersect(SetIterable<? extends T> set) |
Returns the set of all objects that are members of both
this and set . |
<R extends java.util.Set<T>> |
intersectInto(SetIterable<? extends T> set,
R targetSet) |
Same as
SetIterable.intersect(SetIterable) but adds all the objects to targetSet and returns it. |
boolean |
isProperSubsetOf(SetIterable<? extends T> candidateSuperset) |
Returns true if all the members of
this are also members of candidateSuperset and the
two sets are not equal. |
boolean |
isSubsetOf(SetIterable<? extends T> candidateSuperset) |
Returns true if all the members of
this are also members of candidateSuperset . |
abstract MutableSet<T> |
newEmpty(int size) |
|
boolean |
noneSatisfy(Predicate<? super T> predicate) |
Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty.
|
<P> boolean |
noneSatisfyWith(Predicate2<? super T,? super P> predicate,
P parameter) |
Returns true if the predicate evaluates to false for every element of the collection, or return false.
|
MutableSet<UnsortedSetIterable<T>> |
powerSet() |
Returns the set whose members are all possible subsets of
this . |
boolean |
removeAllIterable(java.lang.Iterable<?> iterable) |
|
boolean |
retainAll(java.util.Collection<?> collection) |
|
MutableSet<T> |
symmetricDifference(SetIterable<? extends T> setB) |
Returns the set of all objects that are a member of exactly one of
this and setB (elements which
are in one of the sets, but not in both). |
<R extends java.util.Set<T>> |
symmetricDifferenceInto(SetIterable<? extends T> set,
R targetSet) |
Same as
SetIterable.symmetricDifference(SetIterable) but adds all the objects to targetSet and returns it. |
MutableSet<T> |
union(SetIterable<? extends T> set) |
Returns the set of all objects that are a member of
this or set or both. |
<R extends java.util.Set<T>> |
unionInto(SetIterable<? extends T> set,
R targetSet) |
Same as
SetIterable.union(SetIterable) but adds all the objects to targetSet and returns it. |
<S> MutableSet<Pair<T,S>> |
zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
MutableSet<Pair<T,java.lang.Integer>> |
zipWithIndex() |
Deprecated.
in 6.0. Use
OrderedIterable.zipWithIndex() instead. |
add, addAll, addAllIterable, aggregateBy, aggregateInPlaceBy, countBy, countByWith, reduce, remove, removeAll, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith, sumByDouble, sumByFloat, sumByInt, sumByLong
appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detectWith, detectWithIfNone, detectWithOptional, flatCollect, forEach, forEachWith, forEachWithIndex, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, max, max, maxBy, min, min, minBy, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex
batchForEach, forEach, size
forEach, forEach, forEachWith, forEachWithIndex
addAllIterable, aggregateBy, aggregateInPlaceBy, countBy, countByWith, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith, sumByDouble, sumByFloat, sumByInt, sumByLong
flatCollectWith, groupBy, groupByEach, newEmpty, partition, partitionWith, reject, rejectWith, select, selectInstancesOf, selectWith, tap, toImmutable, with, withAll, without, withoutAll
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear, get, put, removeFromPool, size
appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countBy, countByWith, countWith, detectIfNone, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectWith, 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, 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, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, of, of, of, of, of, of, of, of, of, of, of, of, remove, removeAll, size, spliterator, toArray, toArray
equals, hashCode
asParallel
public abstract MutableSet<T> clone()
clone
in interface MutableSet<T>
clone
in class java.lang.Object
public abstract MutableSet<T> newEmpty(int size)
public int getBatchCount(int batchSize)
getBatchCount
in interface BatchIterable<T>
public <V> UnifiedSet<V> collect(Function<? super T,? extends V> function)
RichIterable
Example using a Java 8 lambda expression:
RichIterable<String> names = people.collect(person -> person.getFirstName() + " " + person.getLastName());
Example using an anonymous inner class:
RichIterable<String> names = people.collect(new Function<Person, String>() { public String valueOf(Person person) { return person.getFirstName() + " " + person.getLastName(); } });
collect
in interface MutableCollection<T>
collect
in interface MutableSet<T>
collect
in interface RichIterable<T>
collect
in interface UnsortedSetIterable<T>
public MutableBooleanSet collectBoolean(BooleanFunction<? super T> booleanFunction)
RichIterable
boolean
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
BooleanIterable licenses = people.collectBoolean(person -> person.hasDrivingLicense());
Example using an anonymous inner class:
BooleanIterable licenses = people.collectBoolean(new BooleanFunction<Person>() { public boolean booleanValueOf(Person person) { return person.hasDrivingLicense(); } });
collectBoolean
in interface MutableCollection<T>
collectBoolean
in interface MutableSet<T>
collectBoolean
in interface RichIterable<T>
collectBoolean
in interface UnsortedSetIterable<T>
public MutableByteSet collectByte(ByteFunction<? super T> byteFunction)
RichIterable
byte
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
ByteIterable bytes = people.collectByte(person -> person.getCode());
Example using an anonymous inner class:
ByteIterable bytes = people.collectByte(new ByteFunction<Person>() { public byte byteValueOf(Person person) { return person.getCode(); } });
collectByte
in interface MutableCollection<T>
collectByte
in interface MutableSet<T>
collectByte
in interface RichIterable<T>
collectByte
in interface UnsortedSetIterable<T>
public MutableCharSet collectChar(CharFunction<? super T> charFunction)
RichIterable
char
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
CharIterable chars = people.collectChar(person -> person.getMiddleInitial());
Example using an anonymous inner class:
CharIterable chars = people.collectChar(new CharFunction<Person>() { public char charValueOf(Person person) { return person.getMiddleInitial(); } });
collectChar
in interface MutableCollection<T>
collectChar
in interface MutableSet<T>
collectChar
in interface RichIterable<T>
collectChar
in interface UnsortedSetIterable<T>
public MutableDoubleSet collectDouble(DoubleFunction<? super T> doubleFunction)
RichIterable
double
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
DoubleIterable doubles = people.collectDouble(person -> person.getMilesFromNorthPole());
Example using an anonymous inner class:
DoubleIterable doubles = people.collectDouble(new DoubleFunction<Person>() { public double doubleValueOf(Person person) { return person.getMilesFromNorthPole(); } });
collectDouble
in interface MutableCollection<T>
collectDouble
in interface MutableSet<T>
collectDouble
in interface RichIterable<T>
collectDouble
in interface UnsortedSetIterable<T>
public MutableFloatSet collectFloat(FloatFunction<? super T> floatFunction)
RichIterable
float
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
FloatIterable floats = people.collectFloat(person -> person.getHeightInInches());
Example using an anonymous inner class:
FloatIterable floats = people.collectFloat(new FloatFunction<Person>() { public float floatValueOf(Person person) { return person.getHeightInInches(); } });
collectFloat
in interface MutableCollection<T>
collectFloat
in interface MutableSet<T>
collectFloat
in interface RichIterable<T>
collectFloat
in interface UnsortedSetIterable<T>
public MutableIntSet collectInt(IntFunction<? super T> intFunction)
RichIterable
int
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
IntIterable ints = people.collectInt(person -> person.getAge());
Example using an anonymous inner class:
IntIterable ints = people.collectInt(new IntFunction<Person>() { public int intValueOf(Person person) { return person.getAge(); } });
collectInt
in interface MutableCollection<T>
collectInt
in interface MutableSet<T>
collectInt
in interface RichIterable<T>
collectInt
in interface UnsortedSetIterable<T>
public MutableLongSet collectLong(LongFunction<? super T> longFunction)
RichIterable
long
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
LongIterable longs = people.collectLong(person -> person.getGuid());
Example using an anonymous inner class:
LongIterable longs = people.collectLong(new LongFunction<Person>() { public long longValueOf(Person person) { return person.getGuid(); } });
collectLong
in interface MutableCollection<T>
collectLong
in interface MutableSet<T>
collectLong
in interface RichIterable<T>
collectLong
in interface UnsortedSetIterable<T>
public MutableShortSet collectShort(ShortFunction<? super T> shortFunction)
RichIterable
short
iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
Example using a Java 8 lambda expression:
ShortIterable shorts = people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
Example using an anonymous inner class:
ShortIterable shorts = people.collectShort(new ShortFunction<Person>() { public short shortValueOf(Person person) { return person.getNumberOfJunkMailItemsReceivedPerMonth(); } });
collectShort
in interface MutableCollection<T>
collectShort
in interface MutableSet<T>
collectShort
in interface RichIterable<T>
collectShort
in interface UnsortedSetIterable<T>
public <V> UnifiedSet<V> flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)
RichIterable
flatCollect
is a special case of RichIterable.collect(Function)
. With collect
, when the Function
returns
a collection, the result is a collection of collections. flatCollect
outputs a single "flattened" collection
instead. This method is commonly called flatMap.
Consider the following example where we have a Person
class, and each Person
has a list of Address
objects. Take the following Function
:
Function<Person, List<Address>> addressFunction = Person::getAddresses; RichIterable<Person> people = ...;Using
collect
returns a collection of collections of addresses.
RichIterable<List<Address>> addresses = people.collect(addressFunction);Using
flatCollect
returns a single flattened list of addresses.
RichIterable<Address> addresses = people.flatCollect(addressFunction);
flatCollect
in interface MutableCollection<T>
flatCollect
in interface MutableSet<T>
flatCollect
in interface RichIterable<T>
flatCollect
in interface UnsortedSetIterable<T>
function
- The Function
to applyfunction
public <P,A> UnifiedSet<A> collectWith(Function2<? super T,? super P,? extends A> function, P parameter)
RichIterable
RichIterable.collect(Function)
with a Function2
and specified parameter which is passed to the block.
Example using a Java 8 lambda expression:
RichIterable<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
Example using an anonymous inner class:
Function2<Integer, Integer, Integer> addParameterFunction = new Function2<Integer, Integer, Integer>() { public Integer value(Integer each, Integer parameter) { return each + parameter; } }; RichIterable<Integer> integers = Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
collectWith
in interface MutableCollection<T>
collectWith
in interface MutableSet<T>
collectWith
in interface RichIterable<T>
collectWith
in interface UnsortedSetIterable<T>
function
- A Function2
to use as the collect transformation functionparameter
- A parameter to pass in for evaluation of the second argument P
in function
RichIterable
that contains the transformed elements returned by Function2.value(Object, Object)
RichIterable.collect(Function)
public <V> UnifiedSet<V> collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)
RichIterable
Example using a Java 8 lambda and method reference:
RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString);
Example using Predicates factory:
RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
collectIf
in interface MutableCollection<T>
collectIf
in interface MutableSet<T>
collectIf
in interface RichIterable<T>
collectIf
in interface UnsortedSetIterable<T>
public T detect(Predicate<? super T> predicate)
RichIterable
Example using a Java 8 lambda expression:
Person person = people.detect(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
Example using an anonymous inner class:
Person person = people.detect(new Predicate<Person>() { public boolean accept(Person person) { return person.getFirstName().equals("John") && person.getLastName().equals("Smith"); } });
detect
in interface RichIterable<T>
detect
in class AbstractRichIterable<T>
public java.util.Optional<T> detectOptional(Predicate<? super T> predicate)
RichIterable
Example using a Java 8 lambda expression:
Person person = people.detectOptional(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
detectOptional
in interface RichIterable<T>
detectOptional
in class AbstractRichIterable<T>
public boolean anySatisfy(Predicate<? super T> predicate)
RichIterable
anySatisfy
in interface RichIterable<T>
anySatisfy
in class AbstractRichIterable<T>
public <P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
anySatisfyWith
in interface RichIterable<T>
anySatisfyWith
in class AbstractRichIterable<T>
public boolean allSatisfy(Predicate<? super T> predicate)
RichIterable
allSatisfy
in interface RichIterable<T>
allSatisfy
in class AbstractRichIterable<T>
public <P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
allSatisfyWith
in interface RichIterable<T>
allSatisfyWith
in class AbstractRichIterable<T>
public boolean noneSatisfy(Predicate<? super T> predicate)
RichIterable
noneSatisfy
in interface RichIterable<T>
noneSatisfy
in class AbstractRichIterable<T>
public <P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
noneSatisfyWith
in interface RichIterable<T>
noneSatisfyWith
in class AbstractRichIterable<T>
public <IV,P> IV injectIntoWith(IV injectValue, Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)
injectIntoWith
in interface MutableCollection<T>
injectIntoWith
in class AbstractMutableCollection<T>
public MutableSet<T> asUnmodifiable()
MutableSet
asUnmodifiable
in interface MutableCollection<T>
asUnmodifiable
in interface MutableSet<T>
Collections.unmodifiableCollection(Collection)
public MutableSet<T> asSynchronized()
MutableCollection
Collections.synchronizedCollection(this)
only with a return type that supports the full
iteration protocols available on MutableCollection
.
The preferred way of iterating over a synchronized collection is to use the internal iteration
methods which are properly synchronized internally.
MutableCollection synchedCollection = collection.asSynchronized(); ... synchedCollection.forEach(each -> ... ); synchedCollection.select(each -> ... ); synchedCollection.collect(each -> ... );If you want to iterate using an imperative style, you must protect external iterators using a synchronized block. This includes explicit iterators as well as JDK 5 style for loops.
asSynchronized
in interface MutableCollection<T>
asSynchronized
in interface MutableSet<T>
Collections.synchronizedCollection(Collection)
public boolean removeAllIterable(java.lang.Iterable<?> iterable)
removeAllIterable
in interface MutableCollection<T>
removeAllIterable
in class AbstractMutableCollection<T>
Collection.removeAll(Collection)
public boolean retainAll(java.util.Collection<?> collection)
retainAll
in interface java.util.Collection<T>
retainAll
in interface java.util.Set<T>
retainAll
in class AbstractMutableCollection<T>
public <V> MutableMap<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
RichIterable
groupByUniqueKey
in interface MutableCollection<T>
groupByUniqueKey
in interface RichIterable<T>
groupByUniqueKey
in class AbstractMutableCollection<T>
RichIterable.groupBy(Function)
@Deprecated public <S> MutableSet<Pair<T,S>> zip(java.lang.Iterable<S> that)
OrderedIterable.zip(Iterable)
instead.RichIterable
RichIterable
formed from this RichIterable
and another RichIterable
by
combining corresponding elements in pairs. If one of the two RichIterable
s is longer than the other, its
remaining elements are ignored.zip
in interface MutableCollection<T>
zip
in interface MutableSet<T>
zip
in interface MutableSetIterable<T>
zip
in interface RichIterable<T>
zip
in interface UnsortedSetIterable<T>
S
- the type of the second half of the returned pairsthat
- The RichIterable
providing the second half of each result pairRichIterable
containing pairs consisting of corresponding elements of this
RichIterable
and that. The length of the returned RichIterable
is the minimum of the lengths of
this RichIterable
and that.@Deprecated public MutableSet<Pair<T,java.lang.Integer>> zipWithIndex()
OrderedIterable.zipWithIndex()
instead.RichIterable
RichIterable
with its indices.zipWithIndex
in interface MutableCollection<T>
zipWithIndex
in interface MutableSet<T>
zipWithIndex
in interface MutableSetIterable<T>
zipWithIndex
in interface RichIterable<T>
zipWithIndex
in interface SetIterable<T>
zipWithIndex
in interface UnsortedSetIterable<T>
RichIterable
containing pairs consisting of all elements of this RichIterable
paired with their index. Indices start at 0.RichIterable.zip(Iterable)
public RichIterable<RichIterable<T>> chunk(int size)
RichIterable
chunk
in interface RichIterable<T>
chunk
in class AbstractMutableCollection<T>
size
- the number of elements per chunkRichIterable
containing RichIterable
s of size size
, except the last will be
truncated if the elements don't divide evenly.public MutableSet<T> union(SetIterable<? extends T> set)
SetIterable
this
or set
or both. The union of [1, 2, 3]
and [2, 3, 4] is the set [1, 2, 3, 4]. If equal elements appear in both sets, then the output will contain the
copy from this
.union
in interface MutableSet<T>
union
in interface SetIterable<T>
union
in interface UnsortedSetIterable<T>
public <R extends java.util.Set<T>> R unionInto(SetIterable<? extends T> set, R targetSet)
SetIterable
SetIterable.union(SetIterable)
but adds all the objects to targetSet
and returns it.unionInto
in interface SetIterable<T>
public MutableSet<T> intersect(SetIterable<? extends T> set)
SetIterable
this
and set
. The intersection of
[1, 2, 3] and [2, 3, 4] is the set [2, 3]. The output will contain instances from this
, not set
.intersect
in interface MutableSet<T>
intersect
in interface SetIterable<T>
intersect
in interface UnsortedSetIterable<T>
public <R extends java.util.Set<T>> R intersectInto(SetIterable<? extends T> set, R targetSet)
SetIterable
SetIterable.intersect(SetIterable)
but adds all the objects to targetSet
and returns it.intersectInto
in interface SetIterable<T>
public MutableSet<T> difference(SetIterable<? extends T> subtrahendSet)
SetIterable
this
that are not members of subtrahendSet
. The difference of
[1, 2, 3] and [2, 3, 4] is [1].difference
in interface MutableSet<T>
difference
in interface SetIterable<T>
difference
in interface UnsortedSetIterable<T>
public <R extends java.util.Set<T>> R differenceInto(SetIterable<? extends T> subtrahendSet, R targetSet)
SetIterable
SetIterable.difference(SetIterable)
but adds all the objects to targetSet
and returns it.differenceInto
in interface SetIterable<T>
public MutableSet<T> symmetricDifference(SetIterable<? extends T> setB)
SetIterable
this
and setB
(elements which
are in one of the sets, but not in both). For instance, for the sets [1, 2, 3] and [2, 3, 4], the symmetric
difference set is [1, 4] . It is the set difference of the union and the intersection.symmetricDifference
in interface MutableSet<T>
symmetricDifference
in interface SetIterable<T>
symmetricDifference
in interface UnsortedSetIterable<T>
public <R extends java.util.Set<T>> R symmetricDifferenceInto(SetIterable<? extends T> set, R targetSet)
SetIterable
SetIterable.symmetricDifference(SetIterable)
but adds all the objects to targetSet
and returns it.symmetricDifferenceInto
in interface SetIterable<T>
public boolean isSubsetOf(SetIterable<? extends T> candidateSuperset)
SetIterable
this
are also members of candidateSuperset
.
For example, [1, 2] is a subset of [1, 2, 3], but [1, 4] is not.isSubsetOf
in interface SetIterable<T>
public boolean isProperSubsetOf(SetIterable<? extends T> candidateSuperset)
SetIterable
this
are also members of candidateSuperset
and the
two sets are not equal. For example, [1, 2] is a proper subset of [1, 2, 3], but [1, 2, 3] is not.isProperSubsetOf
in interface SetIterable<T>
public MutableSet<UnsortedSetIterable<T>> powerSet()
UnsortedSetIterable
this
. For example, the powerset of [1, 2] is
[[], [1], [2], [1, 2]].powerSet
in interface MutableSet<T>
powerSet
in interface UnsortedSetIterable<T>
public <B> LazyIterable<Pair<T,B>> cartesianProduct(SetIterable<B> set)
SetIterable
this
and b is a
member of set
.cartesianProduct
in interface SetIterable<T>
Copyright © 2004–2018. All rights reserved.