java.util
Class TreeSet
java.lang.Object
|
+--java.util.AbstractCollection
|
+--java.util.AbstractSet
|
+--java.util.TreeSet
All Implemented Interfaces:
SortedSet, Cloneable, Serializable, Set, Collection
This class provides a TreeMap-backed implementation of the SortedSet
interface. The elements will be sorted according to their
natural
order, or according to the provided
Comparator
.
Most operations are O(log n), but there is so much overhead that this
makes small sets expensive. Note that the ordering must be consistent
with equals to correctly implement the Set interface. If this
condition is violated, the set is still well-behaved, but you may have
suprising results when comparing it to other sets.
This implementation is not synchronized. If you need to share this between
multiple threads, do something like:
SortedSet s
= Collections.synchronizedSortedSet(new TreeSet(...));
The iterators are fail-fast, meaning that any structural
modification, except for remove()
called on the iterator
itself, cause the iterator to throw a
ConcurrentModificationException
rather than exhibit
non-deterministic behavior.
Since:Authors:- Jon Zeppieri
- Bryce McKinlay
- Eric Blake <ebb9@email.byu.edu>
See Also:
TreeSet
public TreeSet()
Construct a new TreeSet whose backing TreeMap using the "natural"
ordering of keys. Elements that are not mutually comparable will cause
ClassCastExceptions down the road.
See Also:
TreeSet
public TreeSet(java.util.Collection collection)
Construct a new TreeSet whose backing TreeMap uses the "natural"
orering of the keys and which contains all of the elements in the
supplied Collection. This runs in n*log(n) time.
Parameters:
Throws:
See Also:
TreeSet
public TreeSet(java.util.Comparator comparator)
Construct a new TreeSet whose backing TreeMap uses the supplied
Comparator. Elements that are not mutually comparable will cause
ClassCastExceptions down the road.
Parameters:
TreeSet
public TreeSet(java.util.SortedSet sortedSet)
Construct a new TreeSet, using the same key ordering as the supplied
SortedSet and containing all of the elements in the supplied SortedSet.
This constructor runs in linear time.
Parameters:
Throws:
add
public boolean add(java.lang.Object obj)
Adds the spplied Object to the Set if it is not already in the Set;
returns true if the element is added, false otherwise.
Parameters:
Throws:
addAll
public boolean addAll(java.util.Collection c)
Adds all of the elements in the supplied Collection to this TreeSet.
Parameters:
Returns:
- true if the Set is altered, false otherwise
Throws:
clear
public void clear()
Removes all elements in this Set.
clone
public Object clone()
Returns a shallow copy of this Set. The elements are not cloned.
Returns:
comparator
public Comparator comparator()
Returns this Set's comparator.
Returns:
- the comparator, or null if the set uses natural ordering
contains
public boolean contains(java.lang.Object obj)
Returns true if this Set contains the supplied Object, false otherwise.
Parameters:
Returns:
Throws:
first
public Object first()
Returns the first (by order) element in this Set.
Returns:
Throws:
headSet
public SortedSet headSet(java.lang.Object to)
Returns a view of this Set including all elements less than
to
. The returned set is backed by the original, so changes
in one appear in the other. The subset will throw an
IllegalArgumentException for any attempt to access or add an
element beyond the specified cutoff. The returned set does not include
the endpoint; if you want inclusion, pass the successor element.
Parameters:
Returns:
- a view of the set less than the cutoff
Throws:
ClassCastException
- if to
is not compatible with
the comparator (or is not Comparable, for natural ordering)NullPointerException
- if to is null, but the comparator does not
tolerate null elements
isEmpty
public boolean isEmpty()
Returns true if this Set has size 0, false otherwise.
Returns:
iterator
public Iterator iterator()
Returns in Iterator over the elements in this TreeSet, which traverses
in ascending order.
Returns:
last
public Object last()
Returns the last (by order) element in this Set.
Returns:
Throws:
remove
public boolean remove(java.lang.Object obj)
If the supplied Object is in this Set, it is removed, and true is
returned; otherwise, false is returned.
Parameters:
Returns:
- true if the set was modified
Throws:
size
public int size()
Returns the number of elements in this Set
Returns:
subSet
public SortedSet subSet(java.lang.Object from, java.lang.Object to)
Returns a view of this Set including all elements greater or equal to
from
and less than to
(a half-open interval).
The returned set is backed by the original, so changes in one appear in
the other. The subset will throw an IllegalArgumentException
for any attempt to access or add an element beyond the specified cutoffs.
The returned set includes the low endpoint but not the high; if you want
to reverse this behavior on either end, pass in the successor element.
Parameters:
Returns:
- a view of the set between the cutoffs
Throws:
tailSet
public SortedSet tailSet(java.lang.Object from)
Returns a view of this Set including all elements greater or equal to
from
. The returned set is backed by the original, so
changes in one appear in the other. The subset will throw an
IllegalArgumentException for any attempt to access or add an
element beyond the specified cutoff. The returned set includes the
endpoint; if you want to exclude it, pass in the successor element.
Parameters:
Returns:
- a view of the set above the cutoff
Throws:
ClassCastException
- if from
is not compatible with
the comparator (or is not Comparable, for natural ordering)NullPointerException
- if from is null, but the comparator
does not tolerate null elements
Comparator
.Most operations are O(log n), but there is so much overhead that this makes small sets expensive. Note that the ordering must be consistent with equals to correctly implement the Set interface. If this condition is violated, the set is still well-behaved, but you may have suprising results when comparing it to other sets.
This implementation is not synchronized. If you need to share this between multiple threads, do something like:
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
The iterators are fail-fast, meaning that any structural modification, except for
remove()
called on the iterator itself, cause the iterator to throw aConcurrentModificationException
rather than exhibit non-deterministic behavior.