java.util
Class EnumSet<T extends Enum<T>>

java.lang.Object
  extended by java.util.AbstractCollection<E>
      extended by java.util.AbstractSet<T>
          extended by java.util.EnumSet<T>
All Implemented Interfaces:
Serializable, Cloneable, Iterable<T>, Collection<T>, Set<T>

public abstract class EnumSet<T extends Enum<T>>
extends AbstractSet<T>
implements Cloneable, Serializable

Provides an efficient mechanism for recording a set of enumeration constants. As enumerations have a known set of possible values, certain assumptions can be made when creating a set of constants. The maximum size of the set will always be equal to the number of constants, and each value will always be one of these constants. As a result, the set only needs to store whether a particular constant is present or not rather than the values themselves. Each constant can thus be represented by a single bit.

This class is designed to provide an alternative to using integer bit flags by providing a typesafe Collection interface with an underlying implementation that utilises the assumptions above to give an equivalent level of efficiency. The values in a EnumSet must all be from the same Enum type, which allows the contents to be packed into a bit vector. A containment test is then simply a matter of inspecting the appropriate bit, while addition involves setting the same. Such basic operations take place in constant time.

The Iterator implementation traverses the values in the natural order of the enumeration provided by each constant's Enum.ordinal(). It is weakly consistent and will not throw a ConcurrentModificationException. This means that concurrent changes to the set may or may not be noticeable during traversal.

As is usual with most collections, the set is not synchronized by default. This can be remedied by using the Collections.synchronizedSet(Set) method. Null elements are not supported and attempts to add one will throw a NullPointerException.

Since:
1.5
See Also:
Serialized Form

Method Summary
static
<T extends Enum<T>>
EnumSet<T>
allOf(Class<T> eltType)
          Returns a set for the given enumeration type where all the constants are present.
 EnumSet<T> clone()
          Returns a clone of the set.
static
<T extends Enum<T>>
EnumSet<T>
complementOf(EnumSet<T> other)
          Returns a set which is the inverse of the supplied set.
static
<T extends Enum<T>>
EnumSet<T>
copyOf(Collection<T> other)
          Creates an EnumSet using the contents of the given collection.
static
<T extends Enum<T>>
EnumSet<T>
copyOf(EnumSet<T> other)
          Returns a clone of the given set.
static
<T extends Enum<T>>
EnumSet<T>
noneOf(Class<T> eltType)
          Returns a set for the given enumeration type where none of the constants are present.
static
<T extends Enum<T>>
EnumSet<T>
of(T first)
          Creates a new EnumSet populated with the given element.
static
<T extends Enum<T>>
EnumSet<T>
of(T first, T... rest)
          Creates a new EnumSet populated with the given elements.
static
<T extends Enum<T>>
EnumSet<T>
of(T first, T second)
          Creates a new EnumSet populated with the given two elements.
static
<T extends Enum<T>>
EnumSet<T>
of(T first, T second, T third)
          Creates a new EnumSet populated with the given three elements.
static
<T extends Enum<T>>
EnumSet<T>
of(T first, T second, T third, T fourth)
          Creates a new EnumSet populated with the given four elements.
static
<T extends Enum<T>>
EnumSet<T>
of(T first, T second, T third, T fourth, T fifth)
          Creates a new EnumSet populated with the given five elements.
static
<T extends Enum<T>>
EnumSet<T>
range(T from, T to)
          Creates a new EnumSet using the enumeration constants starting from from and ending at to inclusive.
 
Methods inherited from class java.util.AbstractSet
equals, hashCode, removeAll
 
Methods inherited from class java.util.AbstractCollection
add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, retainAll, size, toArray, toArray, toString
 
Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface java.util.Set
add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, retainAll, size, toArray, toArray
 

Method Detail

clone

public EnumSet<T> clone()
Returns a clone of the set.

Overrides:
clone in class Object
Returns:
a clone of the set.
See Also:
Cloneable

allOf

public static <T extends Enum<T>> EnumSet<T> allOf(Class<T> eltType)
Returns a set for the given enumeration type where all the constants are present.

Parameters:
eltType - the type of enumeration to use for the set.
Returns:
an EnumSet with all the bits set.
Throws:
NullPointerException - if the element type is null.

noneOf

public static <T extends Enum<T>> EnumSet<T> noneOf(Class<T> eltType)
Returns a set for the given enumeration type where none of the constants are present.

Parameters:
eltType - the type of enumeration to use for the set.
Returns:
an EnumSet with none of the bits set.
Throws:
NullPointerException - if the element type is null.

copyOf

public static <T extends Enum<T>> EnumSet<T> copyOf(EnumSet<T> other)
Returns a clone of the given set.

Parameters:
other - the set to clone.
Returns:
an EnumSet that is a clone of the given set.
Throws:
NullPointerException - if other is null.

copyOf

public static <T extends Enum<T>> EnumSet<T> copyOf(Collection<T> other)
Creates an EnumSet using the contents of the given collection. If the collection is also an EnumSet, this method works the same as copyOf(EnumSet). Otherwise, the elements of the collection are inspected and used to populate the new set.

Parameters:
other - the collection to use to populate the new set.
Returns:
an EnumSet containing elements from the given collection.
Throws:
NullPointerException - if other is null.
IllegalArgumentException - if the collection is empty.

complementOf

public static <T extends Enum<T>> EnumSet<T> complementOf(EnumSet<T> other)
Returns a set which is the inverse of the supplied set. If a constant is present in the current set, it will not be present in the new set and vice versa.

Parameters:
other - the set to provide the complement of.
Returns:
an EnumSet which is the inverse of the current one.
Throws:
NullPointerException - if other is null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first)
Creates a new EnumSet populated with the given element.

Parameters:
first - the element to use to populate the new set.
Returns:
an EnumSet containing the element.
Throws:
NullPointerException - if first is null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first,
                                                T second)
Creates a new EnumSet populated with the given two elements.

Parameters:
first - the first element to use to populate the new set.
second - the second element to use.
Returns:
an EnumSet containing the elements.
Throws:
NullPointerException - if any of the parameters are null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first,
                                                T second,
                                                T third)
Creates a new EnumSet populated with the given three elements.

Parameters:
first - the first element to use to populate the new set.
second - the second element to use.
third - the third element to use.
Returns:
an EnumSet containing the elements.
Throws:
NullPointerException - if any of the parameters are null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first,
                                                T second,
                                                T third,
                                                T fourth)
Creates a new EnumSet populated with the given four elements.

Parameters:
first - the first element to use to populate the new set.
second - the second element to use.
third - the third element to use.
fourth - the fourth element to use.
Returns:
an EnumSet containing the elements.
Throws:
NullPointerException - if any of the parameters are null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first,
                                                T second,
                                                T third,
                                                T fourth,
                                                T fifth)
Creates a new EnumSet populated with the given five elements.

Parameters:
first - the first element to use to populate the new set.
second - the second element to use.
third - the third element to use.
fourth - the fourth element to use.
fifth - the fifth element to use.
Returns:
an EnumSet containing the elements.
Throws:
NullPointerException - if any of the parameters are null.

of

public static <T extends Enum<T>> EnumSet<T> of(T first,
                                                T... rest)
Creates a new EnumSet populated with the given elements.

Parameters:
first - the first element to use to populate the new set.
rest - the other elements to use.
Returns:
an EnumSet containing the elements.
Throws:
NullPointerException - if any of the parameters are null.

range

public static <T extends Enum<T>> EnumSet<T> range(T from,
                                                   T to)
Creates a new EnumSet using the enumeration constants starting from from and ending at to inclusive. The two may be the same, but they must be in the correct order. So giving the first constant twice would give a set with just that constant set, while supplying the first and second constant will give a set with those two elements. However, specifying the second as the from element followed by an earlier element as the to element will result in an error.

Parameters:
from - the element to start from.
to - the element to end at (may be the same as from.
Returns:
an EnumSet containing the specified range of elements.
Throws:
NullPointerException - if any of the parameters are null.
IllegalArgumentException - if first.compareTo(last) > 0.