|
Java Platform 1.2 Beta 4 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
|
+--java.util.AbstractCollection
|
+--java.util.AbstractSet
|
+--java.util.TreeSet
This implementation provides guaranteed log(n) time cost for the basic operations (add, remove and contains).
Note that the ordering maintained by a TreeSet (whether or not an explicit Comparator is provided) must be total if the TreeSet is to correctly implement the Set interface. (See Comparable or Comparator for a definition of total ordering.) This is so because the Set interface is defined in terms of the equals operation, but a TreeSet performs all key comparisons using its compareTo (or compare) method, so two keys that are deemed equal by this method are, from the standpoint of the TreeSet, equal. The behavior of a TreeSet is well-defined even if its ordering is strictly partial; it just fails to obey the general contract of the Set interface.
Note that this implementation is not synchronized. If multiple threads access a TreeSet concurrently, and at least one of the threads modifies the TreeSet, it must be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the TreeSet. If no such object exists, the TreeSet should be "wrapped" using the Collections.synchronizedSet method. This is best done at creation time, to prevent accidental unsynchronized access to the TreeSet:
Set s = Collections.synchronizedSet(new TreeSet(...));
The Iterators returned by TreeSet's iterator method are fail-fast: if the HashSet is modified at any time after the Iterator is created, in any way except through the Iterator's own remove method, the Iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the Iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.
Collection,
Set,
HashSet,
Comparable,
Comparator,
Collections.synchronizedSet(Set),
TreeMap, Serialized Form| Constructor Summary | |
| TreeSet()
Constructs a new, empty TreeSet, sorted according to the elements' natural order. |
|
| TreeSet(Collection c)
Constructs a new TreeSet containing the elements in the specified Collection, sorted according to the elements' natural order. |
|
| TreeSet(Comparator c)
Constructs a new, empty TreeSet, sorted according to the given comparator. |
|
| TreeSet(SortedSet s)
Constructs a new TreeSet containing the same elements as the given SortedSet, sorted according to the same ordering. |
|
| Method Summary | |
| boolean | add(Object o)
Adds the specified element to this Set if it is not already present. |
| boolean | addAll(Collection c)
Adds all of the elements in the specified Collection to this TreeSet. |
| void | clear()
Removes all of the elements from this Set. |
| Object | clone()
Returns a shallow copy of this TreeSet. |
| Comparator | comparator()
Returns the comparator used to order this TreeMap, or null if this TreeMap uses its keys natural ordering. |
| boolean | contains(Object o)
Returns true if this TreeSet contains the specified element. |
| Object | first()
Returns the first (lowest) element currently in this TreeSet. |
| SortedSet | headSet(Object toElement)
Returns a view of the portion of this TreeSet whose elements are strictly less than toElement. |
| boolean | isEmpty()
Returns true if this TreeSet contains no elements. |
| Iterator | iterator()
Returns an Iterator over the elements in this TreeSet. |
| Object | last()
Returns the last (highest) element currently in this TreeSet. |
| boolean | remove(Object o)
Removes the given element from this Set if it is present. |
| int | size()
Returns the number of elements in this TreeSet (its cardinality). |
| SortedSet | subSet(Object fromElement,
Object toElement)
Returns a view of the portion of this TreeSet whose elements range from fromElement, inclusive, to toElement, exclusive. |
| SortedSet | tailSet(Object fromElement)
Returns a view of the portion of this TreeSet whose elements are strictly less than toElement. |
| Methods inherited from class java.util.AbstractSet | |
| equals , hashCode | |
| Methods inherited from class java.util.AbstractCollection | |
| containsAll , removeAll , retainAll , toArray , toArray , toString | |
| Methods inherited from class java.lang.Object | |
| finalize , getClass , notify , notifyAll , wait , wait , wait | |
| Constructor Detail |
public TreeSet()
Comparablepublic TreeSet(Comparator c)
public TreeSet(Collection c)
public TreeSet(SortedSet s)
| Method Detail |
public Iterator iterator()
public int size()
public boolean isEmpty()
public boolean contains(Object o)
public boolean add(Object o)
o
- element to be added to this Set.public boolean remove(Object o)
o
- object to be removed from this Set, if present.public void clear()
public boolean addAll(Collection c)
c
- elements to be added
public SortedSet subSet(Object fromElement,
Object toElement)
The Set returned by this method will throw an IllegalArgumentException if the user attempts to insert an element outside the specified range.
Note: this method always returns a half-open range (which includes its low endpoint but not its high endpoint). If you need a closed range (which includes both endpoints), and the element type allows for calculation of the successor a given value, merely request the subrange from lowEndpoint to successor(highEndpoint). For example, suppose that s is a Set of Strings. The following idiom obtains a view containing all of the Strings in s from low to high, inclusive:
Set sub = s.subSet(low, high+"\0");A similarly technique can be used to generate an open range (which contains neither endpoint). The following idiom obtains a view containing all of the Strings in s from low to high, exclusive:
Set sub = s.subSet(low+"\0", high);
fromElement
- low endpoint (inclusive) of the subSet.
toElement
- high endpoint (exclusive) of the subSet.public SortedSet headSet(Object toElement)
The Set returned by this method will throw an IllegalArgumentException if the user attempts to insert an element greater than or equal to toElement.
Note: this method always returns a view that does not contain its (high) endpoint. If you need a view that does contain this endpoint, and the element type allows for calculation of the successor a given value, merely request a headSet bounded by successor(highEndpoint). For example, suppose that s is a Set of Strings. The following idiom obtains a view containing all of the Strings in s that are less than or equal to high:
Set head = s.headSet(high+"\0");
toElement
- high endpoint (exclusive) of the headSet.public SortedSet tailSet(Object fromElement)
The Set returned by this method will throw an IllegalArgumentException if the user attempts to insert an element greater than or equal to toElement.
Note: this method always returns a view that contains its (low) endpoint. If you need a view that does not contain this endpoint, and the element type allows for calculation of the successor a given value, merely request a tailSet bounded by successor(lowEndpoint). For example, suppose that s is a Set of Strings. The following idiom obtains a view containing all of the Strings in s that are strictly greater than low:
Set tail = s.tailSet(low+"\0");
fromElement
- low endpoint (inclusive) of the tailSet.public Comparator comparator()
public Object first()
public Object last()
public Object clone()
|
Java Platform 1.2 Beta 4 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||