ariba.util.core
Class SetUtil

java.lang.Object
  ariba.util.core.SetUtil

public final class SetUtil
extends Object

Set Utilities. These are helper functions for dealing with sets.

Field Summary

static SortedSet	EmptySortedSet An immutable, empty SortedSet.
static Class	ImmutableSetClass

Method Summary

static Set	arrayToSet(Object[] array, boolean assertIfDuplicateElementFound) Creates a Set from the objects in the given array. Note, the elements in the array are NOT copied.
static <T> Set<T>	cloneSet(Set<? extends T> set) Clones and returns the specified set if the actual dynamic type of set supports clone (that is, implements Cloneable and has a publicly available clone() method.)
static <T> SortedSet<T>	emptySortedSet()
static <T> T	getAnyElement(Set<T> set) Retrieve a random element from set.
static <T> Set<T>	immutableSet(Set<? extends T> s) Returns a version of the Set that is not modifiable If s is null, null will be returned.
static <T> Set<T>	intersect(Set<? extends T> set1, Set<? extends T> set2) Perform the operation intersect on two given sets.
static boolean	nullOrEmptySet(Set<?> set) Determine if a Set is null or empty.
static <T> Set<T>	set() Constructs an empty optionally type-safe Set.
static <T> Set<T>	set(int initialCapacity) Constructs a Set capable of holding a specified number of elements.
static <T> Set<T>	set(Set<? extends T> source) Creates new Set with the same contents as the given Set.
static <T> SortedSet<T>	sortedSet() Creates an empty SortedSet.
static <T> SortedSet<T>	sortedSet(Comparator<? super T> comparator) Creates an empty SortedSet Given that compX is a Comparator<X>, compY is a Comparator<Y> (and that Y extends X) and comp is a raw Comparator, the following all compile validly.
static <T> SortedSet<T>	sortedSet(SortedSet<? extends T> source) Creates a new SortedSet with the same content as the given SortedSet.
static <T> Set<T>	subtract(Set<? extends T> set1, Set<? extends T> set2) Performs the operation subtract set2 from set1.
static <T> Set<T>	union(Set<? extends T> set1, Set<? extends T> set2) Returns a new Set containing all the elements from two sets

Methods inherited from class java.lang.Object

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

Field Detail

EmptySortedSet

public static final SortedSet EmptySortedSet

An immutable, empty SortedSet.

ImmutableSetClass

public static final Class ImmutableSetClass

Method Detail

set

public static <T> Set<T> set()

Constructs an empty optionally type-safe Set.

To construct a type-safe Set:

• Set<X> typesafe = SetUtil.set()

For a raw Set:

• Set raw = SetUtil.set()

There will be no compile warnings either way.

Returns:

new empty Set

set

public static <T> Set<T> set(int initialCapacity)

Constructs a Set capable of holding a specified number of elements.

To construct a type-safe Set:

• Set<X> typesafe = SetUtil.set(10)

For a raw Set:

• Set raw = SetUtil.set(10)

There will be no compile warnings either way.

Parameters:

initialCapacity - the number of elements this Set is capable of holding before needing to grow.

Returns:

new empty Set with given initial capacity

set

public static <T> Set<T> set(Set<? extends T> source)

Creates new Set with the same contents as the given Set.

Given that setOfX is a Set<X>, setOfY is a Set<Y> (and that Y extends X) and raw is a Set, the following all compile validly.

• Set<X> typesafe = SetUtil.set(setOfX)
• Set<X> typesafe = SetUtil.<X>set(setOfY)
• Set<?> unknown = SetUtil.set(setOfX)

The following constructs compile with an unchecked warning:

• Set<X> typesafe = SetUtil.set(raw)
• Set raw = SetUtil.set(setOfX)

Parameters:

source - source set

Returns:

new Set with same contents as source

Throws:

NullPointerException - if the specified Set is null.

cloneSet

public static <T> Set<T> cloneSet(Set<? extends T> set)

Clones and returns the specified set if the actual dynamic type of set supports clone (that is, implements Cloneable and has a publicly available clone() method.)

If you just want a java.util.Set, then you're better off using set(java.util.Set), since it's guaranteed to work and is probably just as fast on small sets.

Parameters:

set - the Set to clone

Returns:

a new Set of the same type

immutableSet

public static <T> Set<T> immutableSet(Set<? extends T> s)

Returns a version of the Set that is not modifiable If s is null, null will be returned.

Given that setOfX is a Set<X>, setOfY is a Set<Y> (and that Y extends X) and raw is a Set, the following all compile validly.

• Set<X> typesafe = SetUtil.immutableSet(setOfX)
• Set<X> typesafe = SetUtil.<X>immutableSet(setOfY)
• Set<?> unknown = SetUtil.immutableSet(setOfX)

The following constructs compile with an unchecked warning:

• Set<X> typesafe = SetUtil.immutableSet(raw)
• Set raw = SetUtil.immutableSet(setOfX)

Returns:

new Set with same contents as s but is not modifiable

sortedSet

public static <T> SortedSet<T> sortedSet()

Creates an empty SortedSet.

To construct a type-safe Set:

• Set<X> typesafe = SetUtil.sortedSet()

For a raw Set:

• Set raw = SetUtil.set()

There will be no compile warnings either way.

Returns:

new empty SortedSet

See Also:

SortedSet

sortedSet

public static <T> SortedSet<T> sortedSet(Comparator<? super T> comparator)

Creates an empty SortedSet

Given that compX is a Comparator<X>, compY is a Comparator<Y> (and that Y extends X) and comp is a raw Comparator, the following all compile validly.

• Set<X> typesafe = SetUtil.sortedSet(compX)
• Set<X> typesafe = SetUtil.<X>sortedSet(compY)
• Set<?> unknown = SetUtil.immutableSet(compX)

The following constructs compile with an unchecked warning:

• Set<X> typesafe = SetUtil.immutableSet(comp)
• Set raw = SetUtil.immutableSet(compX)

Parameters:

comparator - the non-null comparator that will be used to sort the Set

Returns:

new empty SortedSet

See Also:

SortedSet

sortedSet

public static <T> SortedSet<T> sortedSet(SortedSet<? extends T> source)

Creates a new SortedSet with the same content as the given SortedSet.

Given that setOfX is a SortedSet<X>, setOfY is a SortedSet<Y> (and that Y extends X) and raw is a raw SortedSet, the following all compile validly.

• SortedSet<X> typesafe = SetUtil.sortedSet(setOfX)
• SortedSet<X> typesafe = SetUtil.<X>sortedSet(setOfY)
• SortedSet<?> unknown = SetUtil.sortedSet(setOfX)

The following constructs compile with an unchecked warning:

• SortedSet<X> typesafe = SetUtil.sortedSet(raw)
• SortedSet raw = SetUtil.sortedSet(setOfX)

Parameters:

source - the non-null sorted set based on the given SortedSet

Returns:

SortedSet containing the elements of the source

See Also:

SortedSet

arrayToSet

public static Set arrayToSet(Object[] array,
                             boolean assertIfDuplicateElementFound)

Creates a Set from the objects in the given array.

Note, the elements in the array are NOT copied.

Parameters:

array - to use as the initial contents of the Set; may not be null

assertIfDuplicateElementFound - if true the method asserts if an duplicated element is found in the input array otherwise it will be ignored

Returns:

Set containing objects from the specified array

nullOrEmptySet

public static boolean nullOrEmptySet(Set<?> set)

Determine if a Set is null or empty.

Parameters:

set - object to check

Returns:

true if set is null or empty, false otherwise

getAnyElement

public static <T> T getAnyElement(Set<T> set)

Retrieve a random element from set.

Note that the set can contain null element (at most one).

Parameters:

set - object from which to retrieve an element

Returns:

any element of set if it's not null or empty, assert otherwise.

intersect

public static <T> Set<T> intersect(Set<? extends T> set1,
                                   Set<? extends T> set2)

Perform the operation intersect on two given sets. The operation is nondestructive.

If one of the sets is null or empty the method returns an empty set.

Parameters:

set1 - input set

set2 - input set

Returns:

the intersect of the given sets.

subtract

public static <T> Set<T> subtract(Set<? extends T> set1,
                                  Set<? extends T> set2)

Performs the operation subtract set2 from set1. The operation is nondestructive.

Parameters:

set1 - input set

set2 - input set

Returns:

set containing the elements of the operation set1 - set2. If set1 is null or empty the method returns an empty set. If on the other hand set2 is null or empty the method returns a copy of set1.

union

public static <T> Set<T> union(Set<? extends T> set1,
                               Set<? extends T> set2)

Returns a new Set containing all the elements from two sets

Parameters:

set1 - input set

set2 - input set

Returns:

the union of the given sets.

emptySortedSet

public static <T> SortedSet<T> emptySortedSet()