RubySet

java.lang.Object
- net.sf.rubycollect4j.RubyEnumerable<E>
- - net.sf.rubycollect4j.RubySet<E>

Type Parameters:
E - the type of the elements

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<java.util.Set<E>>, java.lang.Iterable<E>, java.util.Collection<E>, java.util.Set<E>, Ruby.Enumerable<E>, RubyContract.Enumerable<E,Ruby.Enumerator<?>,RubyArray<?>>
```
public final class RubySet<E>
extends RubyEnumerable<E>
implements java.util.Set<E>, java.lang.Comparable<java.util.Set<E>>, java.io.Serializable
```
RubySet implements all methods refer to the Set class of Ruby language.
RubySet is also a Java Set and a Ruby.Enumerable.

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description
`RubySet()` Creates a `RubySet`.
`RubySet(java.lang.Iterable<E> iter)` Creates a `RubySet` by given Set.
`RubySet(java.util.LinkedHashSet<E> set)` Creates a `RubySet` by given LinkedHashSet.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)`
`boolean`	`addAll(java.util.Collection<? extends E> c)`
`RubySet<E>`	`addʔ(E e)` Adds the given object to the set and returns self.
`<S> RubyHash<S,RubySet<E>>`	`classify(TransformBlock<? super E,? extends S> block)` Classifies the set by the return value of the given block and returns a `RubyHash` of {S value => RubySet<E>} pairs.
`void`	`clear()`
`RubySet<E>`	`collectǃ(java.lang.String methodName, java.lang.Object... args)` Transforms each element by given method name in self.
`RubySet<E>`	`collectǃ(TransformBlock<? super E,? extends E> block)` Replaces the elements with ones returned by `RubyEnumerable.collect(TransformBlock)`.
`int`	`compareTo(java.util.Set<E> arg0)`
`boolean`	`contains(java.lang.Object o)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`static <E> RubySet<E>`	`copyOf(java.lang.Iterable<E> elements)` Returns a `RubySet` which copies the elements of given Iterable.
`RubySet<E>`	`delete(E e)` Deletes the given object from the set and returns self.
`RubySet<E>`	`deleteIf(BooleanBlock<? super E> block)` Deletes every element of the set for which block evaluates to true, and returns self.
`RubySet<E>`	`deleteʔ(E e)` Deletes the given object from the set and returns self.
`RubySet<E>`	`difference(java.lang.Iterable<E> iter)` Returns a new set built by duplicating the set, removing every element that appears in the given Iterable.
`boolean`	`disjointʔ(java.lang.Iterable<E> iter)` Returns true if the set and the given Iterable have no element in common.
`<S> RubySet<RubySet<E>>`	`divide(TransformBlock<? super E,? extends S> block)` Divides the set into a set of subsets according to the commonality defined by the given block.
`RubySet<E>`	`each(Block<? super E> block)` Yields each element to the block.
`boolean`	`emptyʔ()` Returns true if the set contains no elements.
`boolean`	`equals(java.lang.Object o)`
`RubySet<E>`	`exclusive(java.lang.Iterable<E> iter)` Returns a new set containing elements exclusive between the set and the given Iterable.
`<S> RubySet<S>`	`flatten()` Returns a new set that is a copy of the set, flattening each containing set recursively.
`RubySet<E>`	`freeze()` Freezes this `RubySet`.
`boolean`	`frozenʔ()` Checks if this `RubySet` is frozen.
`protected java.lang.Iterable<E>`	`getIterable()` Returns an Iterable of elements.
`int`	`hashCode()`
`java.lang.String`	`inspect()` Equivalent to `toString()`.
`RubySet<E>`	`intersection(java.lang.Iterable<E> iter)` Returns a new set containing elements common to the set and the given Iterable.
`boolean`	`intersectʔ(java.lang.Iterable<E> iter)` Returns true if the set and the given Iterable have at least one element in common.
`boolean`	`isEmpty()`
`RubySet<E>`	`keepIf(BooleanBlock<? super E> block)` Deletes every element of the set for which block evaluates to false, and returns self.
`int`	`length()` Equivalent to `size()`.
`RubySet<E>`	`mapǃ(java.lang.String methodName, java.lang.Object... args)` Equivalent to `collectǃ(String, Object...)`.
`RubySet<E>`	`mapǃ(TransformBlock<? super E,? extends E> block)` Equivalent to `collectǃ(TransformBlock)`.
`RubySet<E>`	`merge(java.lang.Iterable<E> iter)` Merges the elements of the given Iterable to the set and returns self.
`static <E> RubySet<E>`	`of(java.util.LinkedHashSet<E> set)` Returns a `RubySet` which wraps the given LinkedHashSet.
`boolean`	`properSubsetʔ(java.util.Set<E> set)` Returns true if the set is a proper subset of the given set.
`boolean`	`properSupersetʔ(java.util.Set<E> set)` Returns true if the set is a proper superset of the given set.
`RubySet<E>`	`rejectǃ(BooleanBlock<? super E> block)` Equivalent to `deleteIf(BooleanBlock)`, but returns null if no changes were made.
`boolean`	`remove(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> c)`
`RubySet<E>`	`replace(java.lang.Iterable<E> iter)` Replaces the contents of the set with the contents of the given Iterable and returns self.
`boolean`	`retainAll(java.util.Collection<?> c)`
`RubySet<E>`	`selectǃ(BooleanBlock<? super E> block)` Equivalent to `keepIf(BooleanBlock)`, but returns null if no changes were made.
`int`	`size()`
`boolean`	`subsetʔ(java.util.Set<E> set)` Returns true if the set is a subset of the given set.
`RubySet<E>`	`subtract(java.lang.Iterable<E> iter)` Deletes every element that appears in the given Iterable and returns self.
`boolean`	`supersetʔ(java.util.Set<E> set)` Returns true if the set is a superset of the given set.
`java.lang.Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`java.lang.String`	`toString()`
`RubySet<E>`	`union(java.lang.Iterable<E> iter)` Returns a new set built by merging the set and the elements of the given Iterable.

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable
allʔ, allʔ, anyʔ, anyʔ, chunk, chunk, collect, collect, collect, collectConcat, collectConcat, count, count, cycle, cycle, cycle, cycle, detect, detect, drop, dropWhile, dropWhile, each, eachCons, eachCons, eachEntry, eachEntry, eachSlice, eachSlice, eachWithIndex, eachWithIndex, eachWithObject, eachWithObject, entries, find, find, findAll, findAll, findIndex, findIndex, findIndex, first, first, flatMap, flatMap, grep, grep, grep, groupBy, groupBy, groupBy, includeʔ, inject, inject, inject, inject, iterator, lazy, map, map, map, max, max, maxBy, maxBy, maxBy, maxBy, memberʔ, min, min, minBy, minBy, minBy, minBy, minmax, minmax, minmaxBy, minmaxBy, minmaxBy, minmaxBy, noneʔ, noneʔ, oneʔ, oneʔ, partition, partition, reduce, reduce, reduce, reduce, reject, reject, reverseEach, reverseEach, select, select, sliceBefore, sliceBefore, sort, sortBy, sortBy, sortBy, sortBy, sortBy, take, takeWhile, takeWhile, toA, zip, zip, zip

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Set
iterator

- Constructor Detail
  - RubySet
```
public RubySet()
```
    Creates a RubySet.
  - RubySet
```
public RubySet(java.util.LinkedHashSet<E> set)
```
    Creates a RubySet by given LinkedHashSet. It's a wrapper implementation. No defensive copy has been made.
    
    Parameters:
    set - any LinkedHashSet
    
    Throws:
    
    java.lang.NullPointerException - if set is null
  - RubySet
```
public RubySet(java.lang.Iterable<E> iter)
```
    Creates a RubySet by given Set.
    
    Parameters:
    iter - any Iterable
    
    Throws:
    
    java.lang.NullPointerException - if iter is null
- Method Detail
  - of
```
public static <E> RubySet<E> of(java.util.LinkedHashSet<E> set)
```
    Returns a RubySet which wraps the given LinkedHashSet.
    
    Parameters:
    set - any LinkedHashSet
    
    Returns:
    RubySet
    
    Throws:
    
    java.lang.NullPointerException - if set is null
  - copyOf
```
public static <E> RubySet<E> copyOf(java.lang.Iterable<E> elements)
```
    Returns a RubySet which copies the elements of given Iterable.
    
    Parameters:
    elements - any Iterable
    
    Returns:
    RubySet
    
    Throws:
    
    java.lang.NullPointerException - if elements is null
  - getIterable
```
protected java.lang.Iterable<E> getIterable()
```
    Description copied from class: RubyEnumerable
    
    Returns an Iterable of elements.
    
    Specified by:
    
    getIterable in class RubyEnumerable<E>
    
    Returns:
    Iterable
  - addʔ
```
public RubySet<E> addʔ(E e)
```
    Adds the given object to the set and returns self. If the object is already in the set, returns null.
    
    Parameters:
    e - an element
    
    Returns:
    this RubySet or null
  - classify
```
public <S> RubyHash<S,RubySet<E>> classify(TransformBlock<? super E,? extends S> block)
```
    Classifies the set by the return value of the given block and returns a RubyHash of {S value => RubySet<E>} pairs.
    
    Parameters:
    block - to transform elements
    
    Returns:
    RubyHash
  - collectǃ
```
public RubySet<E> collectǃ(TransformBlock<? super E,? extends E> block)
```
    Replaces the elements with ones returned by RubyEnumerable.collect(TransformBlock).
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubySet
  - collectǃ
```
public RubySet<E> collectǃ(java.lang.String methodName,
                  java.lang.Object... args)
```
    Transforms each element by given method name in self.
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubySet
  - delete
```
public RubySet<E> delete(E e)
```
    Deletes the given object from the set and returns self.
    
    Parameters:
    e - an element
    
    Returns:
    this RubySet
  - deleteʔ
```
public RubySet<E> deleteʔ(E e)
```
    Deletes the given object from the set and returns self. If the object is not in the set, returns null.
    
    Parameters:
    e - an element
    
    Returns:
    this RubySet or null
  - deleteIf
```
public RubySet<E> deleteIf(BooleanBlock<? super E> block)
```
    Deletes every element of the set for which block evaluates to true, and returns self.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubySet
  - difference
```
public RubySet<E> difference(java.lang.Iterable<E> iter)
```
    Returns a new set built by duplicating the set, removing every element that appears in the given Iterable.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    new RubySet
  - disjointʔ
```
public boolean disjointʔ(java.lang.Iterable<E> iter)
```
    Returns true if the set and the given Iterable have no element in common.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    true if the set and the given Iterable have no element in common, false otherwise
  - divide
```
public <S> RubySet<RubySet<E>> divide(TransformBlock<? super E,? extends S> block)
```
    Divides the set into a set of subsets according to the commonality defined by the given block.
    
    Parameters:
    block - to transform elements
    
    Returns:
    new RubySet of RubySets
  - each
```
public RubySet<E> each(Block<? super E> block)
```
    Yields each element to the block.
    
    Specified by:
    
    each in interface Ruby.Enumerable<E>
    
    Specified by:
    
    each in interface RubyContract.Enumerable<E,Ruby.Enumerator<?>,RubyArray<?>>
    
    Overrides:
    
    each in class RubyEnumerable<E>
    
    Parameters:
    block - to yield each element
    
    Returns:
    this RubySet
  - emptyʔ
```
public boolean emptyʔ()
```
    Returns true if the set contains no elements.
    
    Returns:
    true if the set contains no elements, false otherwise
  - exclusive
```
public RubySet<E> exclusive(java.lang.Iterable<E> iter)
```
    Returns a new set containing elements exclusive between the set and the given Iterable. (set.exclusive(iter)) is equivalent to (set.union(iter).subtract(set.intersection(iter))).
    
    Parameters:
    iter - an Iterable
    
    Returns:
    new RubySet
  - flatten
```
public <S> RubySet<S> flatten()
```
    Returns a new set that is a copy of the set, flattening each containing set recursively.
    
    Returns:
    new RubySet
  - freeze
```
public RubySet<E> freeze()
```
    Freezes this RubySet.
    
    Returns:
    this RubySet
  - frozenʔ
```
public boolean frozenʔ()
```
    Checks if this RubySet is frozen.
    
    Returns:
    true if this RubySet is frozen, false otherwise
  - inspect
```
public java.lang.String inspect()
```
    Equivalent to toString().
    
    Returns:
    String
  - intersectʔ
```
public boolean intersectʔ(java.lang.Iterable<E> iter)
```
    Returns true if the set and the given Iterable have at least one element in common.
    
    Returns:
    true if the set and the given Iterable have at least one element in common, false otherwise
  - intersection
```
public RubySet<E> intersection(java.lang.Iterable<E> iter)
```
    Returns a new set containing elements common to the set and the given Iterable.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    new RubySet
  - keepIf
```
public RubySet<E> keepIf(BooleanBlock<? super E> block)
```
    Deletes every element of the set for which block evaluates to false, and returns self.
    
    Parameters:
    block - to filter elements
    
    Returns:
    this RubySet
  - length
```
public int length()
```
    Equivalent to size().
    
    Returns:
    size of this RubySet
  - mapǃ
```
public RubySet<E> mapǃ(TransformBlock<? super E,? extends E> block)
```
    Equivalent to collectǃ(TransformBlock).
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubySet
  - mapǃ
```
public RubySet<E> mapǃ(java.lang.String methodName,
              java.lang.Object... args)
```
    Equivalent to collectǃ(String, Object...).
    
    Parameters:
    methodName - name of a Method
    args - arguments of a Method
    
    Returns:
    this RubySet
  - merge
```
public RubySet<E> merge(java.lang.Iterable<E> iter)
```
    Merges the elements of the given Iterable to the set and returns self.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    this RubySet
  - properSubsetʔ
```
public boolean properSubsetʔ(java.util.Set<E> set)
```
    Returns true if the set is a proper subset of the given set.
    
    Parameters:
    set - any Set
    
    Returns:
    true if the set is a proper subset of the given set, false otherwise
  - properSupersetʔ
```
public boolean properSupersetʔ(java.util.Set<E> set)
```
    Returns true if the set is a proper superset of the given set.
    
    Parameters:
    set - any Set
    
    Returns:
    true if the set is a proper superset of the given set, false otherwise
  - rejectǃ
```
public RubySet<E> rejectǃ(BooleanBlock<? super E> block)
```
    Equivalent to deleteIf(BooleanBlock), but returns null if no changes were made.
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubySet or null
  - replace
```
public RubySet<E> replace(java.lang.Iterable<E> iter)
```
    Replaces the contents of the set with the contents of the given Iterable and returns self.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    this RubySet
  - selectǃ
```
public RubySet<E> selectǃ(BooleanBlock<? super E> block)
```
    Equivalent to keepIf(BooleanBlock), but returns null if no changes were made.
    
    Parameters:
    block - to transform elements
    
    Returns:
    this RubySet or null
  - subsetʔ
```
public boolean subsetʔ(java.util.Set<E> set)
```
    Returns true if the set is a subset of the given set.
    
    Parameters:
    set - any Set
    
    Returns:
    true if the set is a subset of the given set, false otherwise
  - subtract
```
public RubySet<E> subtract(java.lang.Iterable<E> iter)
```
    Deletes every element that appears in the given Iterable and returns self.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    this RubySet
  - supersetʔ
```
public boolean supersetʔ(java.util.Set<E> set)
```
    Returns true if the set is a superset of the given set.
    
    Parameters:
    set - any Set
    
    Returns:
    true if the set is a superset of the given set, false otherwise
  - union
```
public RubySet<E> union(java.lang.Iterable<E> iter)
```
    Returns a new set built by merging the set and the elements of the given Iterable.
    
    Parameters:
    iter - an Iterable
    
    Returns:
    new RubySet
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface java.util.Collection<E>
    
    Specified by:
    
    add in interface java.util.Set<E>
  - addAll
```
public boolean addAll(java.util.Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface java.util.Collection<E>
    
    Specified by:
    
    addAll in interface java.util.Set<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<E>
    
    Specified by:
    
    clear in interface java.util.Set<E>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Specified by:
    
    contains in interface java.util.Collection<E>
    
    Specified by:
    
    contains in interface java.util.Set<E>
  - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
    Specified by:
    
    containsAll in interface java.util.Collection<E>
    
    Specified by:
    
    containsAll in interface java.util.Set<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<E>
    
    Specified by:
    
    isEmpty in interface java.util.Set<E>
  - remove
```
public boolean remove(java.lang.Object o)
```
    Specified by:
    
    remove in interface java.util.Collection<E>
    
    Specified by:
    
    remove in interface java.util.Set<E>
  - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
    Specified by:
    
    removeAll in interface java.util.Collection<E>
    
    Specified by:
    
    removeAll in interface java.util.Set<E>
  - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
    Specified by:
    
    retainAll in interface java.util.Collection<E>
    
    Specified by:
    
    retainAll in interface java.util.Set<E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<E>
    
    Specified by:
    
    size in interface java.util.Set<E>
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.Set<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.Set<E>
  - equals
```
public boolean equals(java.lang.Object o)
```
    Specified by:
    
    equals in interface java.util.Collection<E>
    
    Specified by:
    
    equals in interface java.util.Set<E>
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Collection<E>
    
    Specified by:
    
    hashCode in interface java.util.Set<E>
    
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class RubyEnumerable<E>
  - compareTo
```
public int compareTo(java.util.Set<E> arg0)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<java.util.Set<E>>

Class RubySet<E>

Constructor Summary

Method Summary

Methods inherited from class net.sf.rubycollect4j.RubyEnumerable

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Set

Constructor Detail

RubySet

RubySet

RubySet

Method Detail

of

copyOf

getIterable

addʔ

classify

collectǃ

collectǃ

delete

deleteʔ

deleteIf

difference

disjointʔ

divide

each

emptyʔ

exclusive

flatten

freeze

frozenʔ

inspect

intersectʔ

intersection

keepIf

length

mapǃ

mapǃ

merge

properSubsetʔ

properSupersetʔ

rejectǃ

replace

selectǃ

subsetʔ

subtract

supersetʔ

union

add

addAll

clear

contains

containsAll

isEmpty

remove

removeAll

retainAll

size

toArray

toArray

equals

hashCode

toString

compareTo