Class AbstractUnifiedSet<T>

    • Field Detail

      • DEFAULT_INITIAL_CAPACITY

        protected static final int DEFAULT_INITIAL_CAPACITY
        See Also:
        Constant Field Values
      • loadFactor

        protected float loadFactor
      • maxSize

        protected int maxSize
    • Constructor Detail

      • AbstractUnifiedSet

        public AbstractUnifiedSet()
    • Method Detail

      • getTable

        protected abstract java.lang.Object[] getTable()
      • allocateTable

        protected abstract void allocateTable​(int sizeToAllocate)
      • rehash

        protected abstract void rehash​(int newCapacity)
      • detect

        protected abstract T detect​(Predicate<? super T> predicate,
                                    int start,
                                    int end)
      • detectOptional

        protected abstract java.util.Optional<T> detectOptional​(Predicate<? super T> predicate,
                                                                int start,
                                                                int end)
      • clone

        public abstract MutableSet<T> clone()
        Specified by:
        clone in interface MutableSet<T>
        Overrides:
        clone in class java.lang.Object
      • newEmpty

        public abstract MutableSet<T> newEmpty​(int size)
      • shortCircuit

        protected abstract boolean shortCircuit​(Predicate<? super T> predicate,
                                                boolean expected,
                                                boolean onShortCircuit,
                                                boolean atEnd,
                                                int start,
                                                int end)
      • shortCircuitWith

        protected abstract <P> boolean shortCircuitWith​(Predicate2<? super T,​? super P> predicate2,
                                                        P parameter,
                                                        boolean expected,
                                                        boolean onShortCircuit,
                                                        boolean atEnd)
      • init

        protected int init​(int initialCapacity)
      • allocate

        protected int allocate​(int capacity)
      • computeMaxSize

        protected void computeMaxSize​(int capacity)
      • rehash

        protected void rehash()
      • shortCircuit

        protected boolean shortCircuit​(Predicate<? super T> predicate,
                                       boolean expected,
                                       boolean onShortCircuit,
                                       boolean atEnd)
      • collect

        public <V> UnifiedSet<V> collect​(Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        Returns a new collection 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:

         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();
                 }
             });
         
        Specified by:
        collect in interface MutableCollection<T>
        Specified by:
        collect in interface MutableSet<T>
        Specified by:
        collect in interface RichIterable<T>
        Specified by:
        collect in interface UnsortedSetIterable<T>
      • flatCollect

        public <V> UnifiedSet<V> flatCollect​(Function<? super T,​? extends java.lang.Iterable<V>> function)
        Description copied from interface: 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);
         
        Specified by:
        flatCollect in interface MutableCollection<T>
        Specified by:
        flatCollect in interface MutableSet<T>
        Specified by:
        flatCollect in interface RichIterable<T>
        Specified by:
        flatCollect in interface UnsortedSetIterable<T>
        Parameters:
        function - The Function to apply
        Returns:
        a new flattened collection produced by applying the given function
      • collectWith

        public <P,​A> UnifiedSet<A> collectWith​(Function2<? super T,​? super P,​? extends A> function,
                                                     P parameter)
        Description copied from interface: RichIterable
        Same as 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));
         
        Specified by:
        collectWith in interface MutableCollection<T>
        Specified by:
        collectWith in interface MutableSet<T>
        Specified by:
        collectWith in interface RichIterable<T>
        Specified by:
        collectWith in interface UnsortedSetIterable<T>
        Parameters:
        function - A Function2 to use as the collect transformation function
        parameter - A parameter to pass in for evaluation of the second argument P in function
        Returns:
        A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
        See Also:
        RichIterable.collect(Function)
      • collectIf

        public <V> UnifiedSet<V> collectIf​(Predicate<? super T> predicate,
                                           Function<? super T,​? extends V> function)
        Description copied from interface: RichIterable
        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. This is the optimized equivalent of calling iterable.select(predicate).collect(function).

        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());
         
        Specified by:
        collectIf in interface MutableCollection<T>
        Specified by:
        collectIf in interface MutableSet<T>
        Specified by:
        collectIf in interface RichIterable<T>
        Specified by:
        collectIf in interface UnsortedSetIterable<T>
      • detect

        public T detect​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no element returns true. This method is commonly called find.

        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");
                 }
             });
         
        Specified by:
        detect in interface RichIterable<T>
        Overrides:
        detect in class AbstractRichIterable<T>
      • detectOptional

        public java.util.Optional<T> detectOptional​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Returns the first element of the iterable for which the predicate evaluates to true as an Optional. This method is commonly called find.

        Example using a Java 8 lambda expression:

         Person person =
             people.detectOptional(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
         

        Specified by:
        detectOptional in interface RichIterable<T>
        Overrides:
        detectOptional in class AbstractRichIterable<T>
      • anySatisfy

        public boolean anySatisfy​(Predicate<? super T> predicate)
        Description copied from interface: RichIterable
        Returns true if the predicate evaluates to true for any element of the iterable. Returns false if the iterable is empty, or if no element returned true when evaluating the predicate.
        Specified by:
        anySatisfy in interface RichIterable<T>
        Overrides:
        anySatisfy in class AbstractRichIterable<T>
      • anySatisfyWith

        public <P> boolean anySatisfyWith​(Predicate2<? super T,​? super P> predicate,
                                          P parameter)
        Description copied from interface: RichIterable
        Returns true if the predicate evaluates to true for any element of the collection, or return false. Returns false if the collection is empty.
        Specified by:
        anySatisfyWith in interface RichIterable<T>
        Overrides:
        anySatisfyWith in class AbstractRichIterable<T>
      • noneSatisfyWith

        public <P> boolean noneSatisfyWith​(Predicate2<? super T,​? super P> predicate,
                                           P parameter)
        Description copied from interface: RichIterable
        Returns true if the predicate evaluates to false for every element of the collection, or return false. Returns true if the collection is empty.
        Specified by:
        noneSatisfyWith in interface RichIterable<T>
        Overrides:
        noneSatisfyWith in class AbstractRichIterable<T>
      • injectIntoWith

        public <IV,​P> IV injectIntoWith​(IV injectValue,
                                              Function3<? super IV,​? super T,​? super P,​? extends IV> function,
                                              P parameter)
        Description copied from interface: MutableCollection
        Returns the final result of evaluating function using each element of the iterable, the previous evaluation result and the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter. The parameter value is always used as the third parameter to the function call.
        Specified by:
        injectIntoWith in interface MutableCollection<T>
        Overrides:
        injectIntoWith in class AbstractMutableCollection<T>
        See Also:
        RichIterable.injectInto(Object, Function2)
      • asSynchronized

        public MutableSet<T> asSynchronized()
        Description copied from interface: MutableCollection
        Returns a synchronized wrapper backed by this collection. This is the equivalent of using 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.

        Specified by:
        asSynchronized in interface MutableCollection<T>
        Specified by:
        asSynchronized in interface MutableSet<T>
        Returns:
        a synchronized view of this collection.
        See Also:
        Collections.synchronizedCollection(Collection)
      • retainAll

        public boolean retainAll​(java.util.Collection<?> collection)
        Specified by:
        retainAll in interface java.util.Collection<T>
        Specified by:
        retainAll in interface java.util.Set<T>
        Overrides:
        retainAll in class AbstractMutableCollection<T>
      • zip

        @Deprecated
        public <S> MutableSet<Pair<T,​S>> zip​(java.lang.Iterable<S> that)
        Deprecated.
        in 6.0. Use OrderedIterable.zip(Iterable) instead.
        Description copied from interface: RichIterable
        Returns a RichIterable formed from this RichIterable and another RichIterable by combining corresponding elements in pairs. If one of the two RichIterables is longer than the other, its remaining elements are ignored.
        Specified by:
        zip in interface MutableCollection<T>
        Specified by:
        zip in interface MutableSet<T>
        Specified by:
        zip in interface MutableSetIterable<T>
        Specified by:
        zip in interface RichIterable<T>
        Specified by:
        zip in interface UnsortedSetIterable<T>
        Type Parameters:
        S - the type of the second half of the returned pairs
        Parameters:
        that - The RichIterable providing the second half of each result pair
        Returns:
        A new RichIterable 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.
      • chunk

        public RichIterable<RichIterable<T>> chunk​(int size)
        Description copied from interface: RichIterable
        Partitions elements in fixed size chunks.
        Specified by:
        chunk in interface RichIterable<T>
        Overrides:
        chunk in class AbstractMutableCollection<T>
        Parameters:
        size - the number of elements per chunk
        Returns:
        A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.
      • union

        public MutableSet<T> union​(SetIterable<? extends T> set)
        Description copied from interface: SetIterable
        Returns the set of all objects that are a member of 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.
        Specified by:
        union in interface MutableSet<T>
        Specified by:
        union in interface SetIterable<T>
        Specified by:
        union in interface UnsortedSetIterable<T>
      • isSubsetOf

        public boolean isSubsetOf​(SetIterable<? extends T> candidateSuperset)
        Description copied from interface: SetIterable
        Returns true if all the members of this are also members of candidateSuperset. For example, [1, 2] is a subset of [1, 2, 3], but [1, 4] is not.
        Specified by:
        isSubsetOf in interface SetIterable<T>
      • isProperSubsetOf

        public boolean isProperSubsetOf​(SetIterable<? extends T> candidateSuperset)
        Description copied from interface: SetIterable
        Returns true if all the members of 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.
        Specified by:
        isProperSubsetOf in interface SetIterable<T>