Package org.eclipse.collections.impl.set.fixed

Class TripletonSet<T>

    • Field Detail

      • element1

        private T element1

      • element2

        private T element2

      • element3

        private T element3

    • Constructor Detail

      • TripletonSet

        public TripletonSet()

      • TripletonSet

        TripletonSet​(T obj1,
             T obj2,
             T obj3)

    • Method Detail

      • size

        public int size()
        Description copied from interface: RichIterable
        Returns the number of items in this iterable.
        Specified by:
        size in interface java.util.Collection<T>
        Specified by:
        size in interface RichIterable<T>
        Specified by:
        size in interface java.util.Set<T>

      • equals

        public boolean equals​(java.lang.Object o)
        Description copied from interface: SetIterable
        Follows the same general contract as Set.equals(Object).
        Specified by:
        equals in interface java.util.Collection<T>
        Specified by:
        equals in interface java.util.Set<T>
        Specified by:
        equals in interface SetIterable<T>
        Overrides:
        equals in class java.lang.Object

      • hashCode

        public int hashCode()
        Description copied from interface: SetIterable
        Follows the same general contract as Set.hashCode().
        Specified by:
        hashCode in interface java.util.Collection<T>
        Specified by:
        hashCode in interface java.util.Set<T>
        Specified by:
        hashCode in interface SetIterable<T>
        Overrides:
        hashCode in class java.lang.Object

      • contains

        public boolean contains​(java.lang.Object obj)
        Description copied from interface: RichIterable
        Returns true if the iterable has an element which responds true to element.equals(object).
        Specified by:
        contains in interface java.util.Collection<T>
        Specified by:
        contains in interface RichIterable<T>
        Specified by:
        contains in interface java.util.Set<T>
        Overrides:
        contains in class AbstractRichIterable<T>

      • iterator

        public java.util.Iterator<T> iterator()
        Specified by:
        iterator in interface java.util.Collection<T>
        Specified by:
        iterator in interface java.lang.Iterable<T>
        Specified by:
        iterator in interface java.util.Set<T>

      • getFirst

        public T getFirst()
        Description copied from interface: RichIterable
        Returns the first element of an iterable. In the case of a List it is the element at the first index. In the case of any other Collection, it is the first element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

        The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the first element could be any element from the Set.

        Specified by:
        getFirst in interface RichIterable<T>

      • getSecond

        T getSecond()

      • getLast

        public T getLast()
        Description copied from interface: RichIterable
        Returns the last element of an iterable. In the case of a List it is the element at the last index. In the case of any other Collection, it is the last element that would be returned during an iteration. If the iterable is empty, null is returned. If null is a valid element of the container, then a developer would need to check to see if the iterable is empty to validate that a null result was not due to the container being empty.

        The order of Sets are not guaranteed (except for TreeSets and other Ordered Set implementations), so if you use this method, the last element could be any element from the Set.

        Specified by:
        getLast in interface RichIterable<T>

      • getOnly

        public T getOnly()
        Description copied from interface: RichIterable
        Returns the element if the iterable has exactly one element. Otherwise, throw IllegalStateException.
        Specified by:
        getOnly in interface RichIterable<T>
        Returns:
        an element of an iterable.

      • each

        public void each​(Procedure<? super T> procedure)
        Description copied from interface: RichIterable
        The procedure is executed for each element in the iterable.

        Example using a Java 8 lambda expression: 

         people.each(person -> LOGGER.info(person.getName()));
        This method is a variant of InternalIterable.forEach(Procedure) that has a signature conflict with Iterable.forEach(java.util.function.Consumer).
        Specified by:
        each in interface RichIterable<T>
        See Also:
        InternalIterable.forEach(Procedure), Iterable.forEach(java.util.function.Consumer)

      • forEachWithIndex

        public void forEachWithIndex​(ObjectIntProcedure<? super T> objectIntProcedure)
        Description copied from interface: InternalIterable
        Iterates over the iterable passing each element and the current relative int index to the specified instance of ObjectIntProcedure.

        Example using a Java 8 lambda: 

         people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));

        Example using an anonymous inner class: 

         people.forEachWithIndex(new ObjectIntProcedure<Person>()
 {
     public void value(Person person, int index)
     {
         LOGGER.info("Index: " + index + " person: " + person.getName());
     }
 });
        Specified by:
        forEachWithIndex in interface InternalIterable<T>
        Overrides:
        forEachWithIndex in class AbstractRichIterable<T>

      • forEachWith

        public <P> void forEachWith​(Procedure2<? super T,​? super P> procedure,
                            P parameter)
        Description copied from interface: InternalIterable
        The procedure2 is evaluated for each element in the iterable with the specified parameter provided as the second argument.

        Example using a Java 8 lambda: 

         people.forEachWith((Person person, Person other) ->
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }, fred);

        Example using an anonymous inner class: 

         people.forEachWith(new Procedure2<Person, Person>()
 {
     public void value(Person person, Person other)
     {
         if (person.isRelatedTo(other))
         {
              LOGGER.info(person.getName());
         }
     }
 }, fred);
        Specified by:
        forEachWith in interface InternalIterable<T>
        Overrides:
        forEachWith in class AbstractRichIterable<T>

      • writeExternal

        public void writeExternal​(java.io.ObjectOutput out)
                   throws java.io.IOException
        Specified by:
        writeExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException

      • readExternal

        public void readExternal​(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
        Specified by:
        readExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException
        java.lang.ClassNotFoundException

      • with

        public MutableSet<T> with​(T element)
        Description copied from interface: MutableCollection
        This method allows mutable and fixed size collections the ability to add elements to their existing elements. In order to support fixed size a new instance of a collection would have to be returned taking the elements of the original collection and appending the new element to form the new collection. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken: 
         MutableCollection<String> list = list.with("1");
 list = list.with("2");
 return list;
        In the case of FixedSizeCollection a new instance of MutableCollection will be returned by with, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling add on itself.
        Specified by:
        with in interface FixedSizeCollection<T>
        Specified by:
        with in interface FixedSizeSet<T>
        Specified by:
        with in interface MutableCollection<T>
        Specified by:
        with in interface MutableSet<T>
        Specified by:
        with in interface MutableSetIterable<T>
        See Also:
        Collection.add(Object)

      • without

        public MutableSet<T> without​(T element)
        Description copied from interface: MutableCollection
        This method allows mutable and fixed size collections the ability to remove elements from their existing elements. In order to support fixed size a new instance of a collection would have to be returned containing the elements that would be left from the original collection after calling remove. In the case of mutable collections, the original collection is modified, and is returned. In order to use this method properly with mutable and fixed size collections the following approach must be taken: 
         MutableCollection<String> list = list.without("1");
 list = list.without("2");
 return list;
        In the case of FixedSizeCollection a new instance of MutableCollection will be returned by without, and any variables that previously referenced the original collection will need to be redirected to reference the new instance. For other MutableCollection types you will replace the reference to collection with the same collection, since the instance will return "this" after calling remove on itself.
        Specified by:
        without in interface FixedSizeCollection<T>
        Specified by:
        without in interface FixedSizeSet<T>
        Specified by:
        without in interface MutableCollection<T>
        Specified by:
        without in interface MutableSet<T>
        Specified by:
        without in interface MutableSetIterable<T>
        See Also:
        Collection.remove(Object)