com.gs.collections.impl.factory

Class Sets

java.lang.Object

com.gs.collections.impl.factory.Sets

public final class Sets
extends java.lang.Object

Set algebra operations are available in this class as static utility.

Most operations are non-destructive, i.e. no input sets are modified during execution. The exception is operations ending in "Into." These accept the target collection of the final calculation as the first parameter.

Some effort is made to return a SortedSet if any input set is sorted, but this is not guaranteed (e.g., this will not be the case for collections proxied by Hibernate). When in doubt, specify the target collection explicitly with the "Into" version. This class should be used to create instances of MutableSet, ImmutableSet and FixedSizeSet

Mutable Examples:

 MutableSet<String> emptySet = Sets.mutable.empty();
 MutableSet<String> setWith = Sets.mutable.with("a", "b", "c");
 MutableSet<String> setOf = Sets.mutable.of("a", "b", "c");
 

Immutable Examples:

 ImmutableSet<String> emptySet = Sets.immutable.empty();
 ImmutableSet<String> setWith = Sets.immutable.with("a", "b", "c");
 ImmutableSet<String> setOf = Sets.immutable.of("a", "b", "c");
 

FixedSize Examples:

 FixedSizeList<String> emptySet = Sets.fixedSize.empty();
 FixedSizeList<String> setWith = Sets.fixedSize.with("a", "b", "c");
 FixedSizeList<String> setOf = Sets.fixedSize.of("a", "b", "c");
 

Field Summary

Fields

Modifier and Type	Field and Description
static com.gs.collections.api.factory.set.FixedSizeSetFactory	fixedSize
static com.gs.collections.api.factory.set.ImmutableSetFactory	immutable
static com.gs.collections.api.factory.set.MutableSetFactory	mutable

Method Summary

Methods

Modifier and Type	Method and Description
static <A,B> com.gs.collections.api.LazyIterable<com.gs.collections.api.tuple.Pair<A,B>>	cartesianProduct(java.util.Set<A> set1, java.util.Set<B> set2)
static <E> com.gs.collections.api.set.MutableSet<E>	difference(java.util.Set<? extends E> minuendSet, java.util.Set<? extends E> subtrahendSet)
static <E> com.gs.collections.api.set.MutableSet<E>	differenceAll(java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	differenceAllInto(R targetSet, java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	differenceInto(R targetSet, java.util.Set<? extends E> minuendSet, java.util.Set<? extends E> subtrahendSet)
static <E> com.gs.collections.api.set.MutableSet<E>	intersect(java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)
static <E> com.gs.collections.api.set.MutableSet<E>	intersectAll(java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	intersectAllInto(R targetSet, java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	intersectInto(R targetSet, java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)
static <E> boolean	isProperSubsetOf(java.util.Set<? extends E> candidateSubset, java.util.Set<? extends E> candidateSuperset)
static <E> boolean	isSubsetOf(java.util.Set<? extends E> candidateSubset, java.util.Set<? extends E> candidateSuperset)
static <T> com.gs.collections.api.set.MutableSet<com.gs.collections.api.set.MutableSet<T>>	powerSet(java.util.Set<T> set)
static <E> com.gs.collections.api.set.MutableSet<E>	symmetricDifference(java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)
static <E,R extends java.util.Set<E>> R	symmetricDifferenceInto(R targetSet, java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)
static <E> com.gs.collections.api.set.MutableSet<E>	union(java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)
static <E> com.gs.collections.api.set.MutableSet<E>	unionAll(java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	unionAllInto(R targetSet, java.util.Set<? extends E>... sets)
static <E,R extends java.util.Set<E>> R	unionInto(R targetSet, java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

immutable

public static final com.gs.collections.api.factory.set.ImmutableSetFactory immutable

fixedSize

public static final com.gs.collections.api.factory.set.FixedSizeSetFactory fixedSize

mutable

public static final com.gs.collections.api.factory.set.MutableSetFactory mutable

Method Detail

union

public static <E> com.gs.collections.api.set.MutableSet<E> union(java.util.Set<? extends E> setA,
                                                 java.util.Set<? extends E> setB)

unionInto

public static <E,R extends java.util.Set<E>> R unionInto(R targetSet,
                                         java.util.Set<? extends E> setA,
                                         java.util.Set<? extends E> setB)

unionAll

public static <E> com.gs.collections.api.set.MutableSet<E> unionAll(java.util.Set<? extends E>... sets)

unionAllInto

public static <E,R extends java.util.Set<E>> R unionAllInto(R targetSet,
                                            java.util.Set<? extends E>... sets)

intersect

public static <E> com.gs.collections.api.set.MutableSet<E> intersect(java.util.Set<? extends E> setA,
                                                     java.util.Set<? extends E> setB)

intersectInto

public static <E,R extends java.util.Set<E>> R intersectInto(R targetSet,
                                             java.util.Set<? extends E> setA,
                                             java.util.Set<? extends E> setB)

intersectAll

public static <E> com.gs.collections.api.set.MutableSet<E> intersectAll(java.util.Set<? extends E>... sets)

intersectAllInto

public static <E,R extends java.util.Set<E>> R intersectAllInto(R targetSet,
                                                java.util.Set<? extends E>... sets)

difference

public static <E> com.gs.collections.api.set.MutableSet<E> difference(java.util.Set<? extends E> minuendSet,
                                                      java.util.Set<? extends E> subtrahendSet)

differenceInto

public static <E,R extends java.util.Set<E>> R differenceInto(R targetSet,
                                              java.util.Set<? extends E> minuendSet,
                                              java.util.Set<? extends E> subtrahendSet)

differenceAll

public static <E> com.gs.collections.api.set.MutableSet<E> differenceAll(java.util.Set<? extends E>... sets)

differenceAllInto

public static <E,R extends java.util.Set<E>> R differenceAllInto(R targetSet,
                                                 java.util.Set<? extends E>... sets)

symmetricDifference

public static <E> com.gs.collections.api.set.MutableSet<E> symmetricDifference(java.util.Set<? extends E> setA,
                                                               java.util.Set<? extends E> setB)

symmetricDifferenceInto

public static <E,R extends java.util.Set<E>> R symmetricDifferenceInto(R targetSet,
                                                       java.util.Set<? extends E> setA,
                                                       java.util.Set<? extends E> setB)

isSubsetOf

public static <E> boolean isSubsetOf(java.util.Set<? extends E> candidateSubset,
                     java.util.Set<? extends E> candidateSuperset)

isProperSubsetOf

public static <E> boolean isProperSubsetOf(java.util.Set<? extends E> candidateSubset,
                           java.util.Set<? extends E> candidateSuperset)

powerSet

public static <T> com.gs.collections.api.set.MutableSet<com.gs.collections.api.set.MutableSet<T>> powerSet(java.util.Set<T> set)

cartesianProduct

public static <A,B> com.gs.collections.api.LazyIterable<com.gs.collections.api.tuple.Pair<A,B>> cartesianProduct(java.util.Set<A> set1,
                                                                                                 java.util.Set<B> set2)