Class 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:
     FixedSizeSet<String> emptySet = Sets.fixedSize.empty();
     FixedSizeSet<String> setWith = Sets.fixedSize.with("a", "b", "c");
     FixedSizeSet<String> setOf = Sets.fixedSize.of("a", "b", "c");
     
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private Sets()  
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static <T> MutableSet<T> adapt​(java.util.Set<T> list)  
      private static <E,​R extends java.util.Set<E>>
      Procedure2<java.util.Set<? extends E>,​R>
      addAllProcedure()  
      static <A,​B>
      LazyIterable<Pair<A,​B>>
      cartesianProduct​(java.util.Set<A> set1, java.util.Set<B> set2)  
      static <A,​B,​C>
      LazyIterable<C>
      cartesianProduct​(java.util.Set<A> set1, java.util.Set<B> set2, Function2<? super A,​? super B,​? extends C> function)  
      static <E> MutableSet<E> difference​(java.util.Set<? extends E> minuendSet, java.util.Set<? extends E> subtrahendSet)  
      static <E> 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)  
      private static <E> java.util.Comparator<? super E> extractComparator​(java.util.Set<? extends E>... sets)  
      private static <E,​R extends java.util.Set<E>>
      R
      fillSet​(R targetSet, Procedure2<java.util.Set<? extends E>,​R> procedure, java.util.Set<? extends E>... sets)  
      static <E> MutableSet<E> intersect​(java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)  
      static <E> 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)  
      private static <E> MutableSet<E> newSet​(java.util.Set<? extends E>... sets)  
      static <T> MutableSet<MutableSet<T>> powerSet​(java.util.Set<T> set)  
      private static <E,​R extends java.util.Set<E>>
      Procedure2<java.util.Set<? extends E>,​R>
      removeAllProcedure()  
      private static <E,​R extends java.util.Set<E>>
      Procedure2<java.util.Set<? extends E>,​R>
      retainAllProcedure()  
      static <E> 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> MutableSet<E> union​(java.util.Set<? extends E> setA, java.util.Set<? extends E> setB)  
      static <E> 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
    • Constructor Detail

      • Sets

        private Sets()
    • Method Detail

      • adapt

        public static <T> MutableSet<T> adapt​(java.util.Set<T> list)
        Since:
        9.0.
      • union

        public static <E> 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> 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> 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> 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> 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> 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> 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)
      • newSet

        private static <E> MutableSet<E> newSet​(java.util.Set<? extends E>... sets)
      • extractComparator

        private static <E> java.util.Comparator<? super E> extractComparator​(java.util.Set<? extends E>... sets)
      • fillSet

        private static <E,​R extends java.util.Set<E>> R fillSet​(R targetSet,
                                                                      Procedure2<java.util.Set<? extends E>,​R> procedure,
                                                                      java.util.Set<? extends E>... sets)
      • addAllProcedure

        private static <E,​R extends java.util.Set<E>> Procedure2<java.util.Set<? extends E>,​R> addAllProcedure()
      • retainAllProcedure

        private static <E,​R extends java.util.Set<E>> Procedure2<java.util.Set<? extends E>,​R> retainAllProcedure()
      • removeAllProcedure

        private static <E,​R extends java.util.Set<E>> Procedure2<java.util.Set<? extends E>,​R> removeAllProcedure()
      • cartesianProduct

        public static <A,​B> LazyIterable<Pair<A,​B>> cartesianProduct​(java.util.Set<A> set1,
                                                                                 java.util.Set<B> set2)
      • cartesianProduct

        public static <A,​B,​C> LazyIterable<C> cartesianProduct​(java.util.Set<A> set1,
                                                                           java.util.Set<B> set2,
                                                                           Function2<? super A,​? super B,​? extends C> function)