|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectjava.util.AbstractCollection<E>
java.util.AbstractSet<T>
java.util.TreeSet<T>
public class TreeSet<T>
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.
Collection,
Set,
HashSet,
LinkedHashSet,
Comparable,
Comparator,
Collections.synchronizedSortedSet(SortedSet),
TreeMap,
Serialized Form| Constructor Summary | |
|---|---|
TreeSet()
Construct a new TreeSet whose backing TreeMap using the "natural" ordering of keys. |
|
TreeSet(Collection<? extends T> 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. |
|
TreeSet(Comparator<? super T> comparator)
Construct a new TreeSet whose backing TreeMap uses the supplied Comparator. |
|
TreeSet(SortedSet<T> sortedSet)
Construct a new TreeSet, using the same key ordering as the supplied SortedSet and containing all of the elements in the supplied SortedSet. |
|
| Method Summary | |
|---|---|
boolean |
add(T 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. |
boolean |
addAll(Collection<? extends T> c)
Adds all of the elements in the supplied Collection to this TreeSet. |
T |
ceiling(T e)
Returns the least or lowest element in the set greater than or equal to the given element, or null if there is
no such element. |
void |
clear()
Removes all elements in this Set. |
Object |
clone()
Returns a shallow copy of this Set. |
Comparator<? super T> |
comparator()
Returns this Set's comparator. |
boolean |
contains(Object obj)
Returns true if this Set contains the supplied Object, false otherwise. |
Iterator<T> |
descendingIterator()
Returns an iterator over the elements of this set in descending order. |
java.util.NavigableSet<T> |
descendingSet()
Returns a view of the set in reverse order. |
T |
first()
Returns the first (by order) element in this Set. |
T |
floor(T e)
Returns the greatest or highest element in the set less than or equal to the given element, or null if there is
no such element. |
SortedSet<T> |
headSet(T to)
Returns a view of this Set including all elements less than to. |
java.util.NavigableSet<T> |
headSet(T to,
boolean inclusive)
Returns a view of this Set including all elements less than (or equal to, if inclusive is true) to. |
T |
higher(T e)
Returns the least or lowest element in the set strictly greater than the given element, or null if there is
no such element. |
boolean |
isEmpty()
Returns true if this Set has size 0, false otherwise. |
Iterator<T> |
iterator()
Returns in Iterator over the elements in this TreeSet, which traverses in ascending order. |
T |
last()
Returns the last (by order) element in this Set. |
T |
lower(T e)
Returns the greatest or highest element in the set strictly less than the given element, or null if there is
no such element. |
T |
pollFirst()
Removes and returns the least or lowest element in the set, or null if the map is empty. |
T |
pollLast()
Removes and returns the greatest or highest element in the set, or null if the map is empty. |
boolean |
remove(Object obj)
If the supplied Object is in this Set, it is removed, and true is returned; otherwise, false is returned. |
int |
size()
Returns the number of elements in this Set |
java.util.NavigableSet<T> |
subSet(T from,
boolean fromInclusive,
T to,
boolean toInclusive)
Returns a view of this Set including all elements greater than (or equal to, if fromInclusive is true from and less than
(or equal to, if toInclusive is true) to. |
SortedSet<T> |
subSet(T from,
T to)
Returns a view of this Set including all elements greater or equal to from and less than to (a half-open interval). |
SortedSet<T> |
tailSet(T from)
Returns a view of this Set including all elements greater or equal to from. |
java.util.NavigableSet<T> |
tailSet(T from,
boolean inclusive)
Returns a view of this Set including all elements greater (or equal to, if inclusive is true) from. |
| Methods inherited from class java.util.AbstractSet |
|---|
equals, hashCode, removeAll |
| Methods inherited from class java.util.AbstractCollection |
|---|
containsAll, retainAll, toArray, toArray, toString |
| Methods inherited from class java.lang.Object |
|---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.util.Set |
|---|
containsAll, equals, hashCode, removeAll, retainAll, toArray, toArray |
| Constructor Detail |
|---|
public TreeSet()
Comparablepublic TreeSet(Comparator<? super T> comparator)
comparator - the Comparator this Set will usepublic TreeSet(Collection<? extends T> collection)
collection - the new Set will be initialized with all
of the elements in this Collection
ClassCastException - if the elements of the collection are not
comparable
NullPointerException - if the collection is nullComparablepublic TreeSet(SortedSet<T> sortedSet)
sortedSet - the new TreeSet will use this SortedSet's comparator
and will initialize itself with all its elements
NullPointerException - if sortedSet is null| Method Detail |
|---|
public boolean add(T obj)
add in interface Collection<T>add in interface Set<T>add in class AbstractCollection<T>obj - the Object to be added to this Set
ClassCastException - if the element cannot be compared with objects
already in the setpublic boolean addAll(Collection<? extends T> c)
addAll in interface Collection<T>addAll in interface Set<T>addAll in class AbstractCollection<T>c - The collection to add
NullPointerException - if c is null
ClassCastException - if an element in c cannot be compared with
objects already in the setAbstractCollection.add(Object)public void clear()
clear in interface Collection<T>clear in interface Set<T>clear in class AbstractCollection<T>Iterator.remove()public Object clone()
clone in class ObjectCloneablepublic Comparator<? super T> comparator()
comparator in interface SortedSet<T>public boolean contains(Object obj)
contains in interface Collection<T>contains in interface Set<T>contains in class AbstractCollection<T>obj - the Object to check for
ClassCastException - if obj cannot be compared with objects
already in the setpublic T first()
first in interface SortedSet<T>NoSuchElementException - if the set is emptypublic SortedSet<T> headSet(T to)
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 or
call #headSet(T,boolean). This call is equivalent to
headSet(to, false).
headSet in interface java.util.NavigableSet<T>headSet in interface SortedSet<T>to - the (exclusive) cutoff point
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
public java.util.NavigableSet<T> headSet(T to,
boolean inclusive)
inclusive is true) 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.
headSet in interface java.util.NavigableSet<T>to - the cutoff pointinclusive - true if to should be included.
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 elementspublic boolean isEmpty()
isEmpty in interface Collection<T>isEmpty in interface Set<T>isEmpty in class AbstractCollection<T>AbstractCollection.size()public Iterator<T> iterator()
iterator in interface Iterable<T>iterator in interface Collection<T>iterator in interface java.util.NavigableSet<T>iterator in interface Set<T>iterator in class AbstractCollection<T>public T last()
last in interface SortedSet<T>NoSuchElementException - if the set is emptypublic boolean remove(Object obj)
remove in interface Collection<T>remove in interface Set<T>remove in class AbstractCollection<T>obj - the Object to remove from this Set
ClassCastException - if obj cannot be compared to set elementsIterator.remove()public int size()
size in interface Collection<T>size in interface Set<T>size in class AbstractCollection<T>
public SortedSet<T> subSet(T from,
T 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
or call #subSet(T,boolean,T,boolean). This is equivalent to
calling subSet(from,true,to,false).
subSet in interface java.util.NavigableSet<T>subSet in interface SortedSet<T>from - the (inclusive) low cutoff pointto - the (exclusive) high cutoff point
ClassCastException - if either cutoff is not compatible with
the comparator (or is not Comparable, for natural ordering)
NullPointerException - if from or to is null, but the comparator
does not tolerate null elements
IllegalArgumentException - if from is greater than to
public java.util.NavigableSet<T> subSet(T from,
boolean fromInclusive,
T to,
boolean toInclusive)
fromInclusive is true from and less than
(or equal to, if toInclusive is true) 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 cutoffs.
subSet in interface java.util.NavigableSet<T>from - the low cutoff pointfromInclusive - true if from should be included.to - the high cutoff pointtoInclusive - true if to should be included.
ClassCastException - if either cutoff is not compatible with
the comparator (or is not Comparable, for natural ordering)
NullPointerException - if from or to is null, but the comparator
does not tolerate null elements
IllegalArgumentException - if from is greater than topublic SortedSet<T> tailSet(T from)
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
or call #tailSet(T,boolean). This is equivalent to calling
tailSet(from, true).
tailSet in interface java.util.NavigableSet<T>tailSet in interface SortedSet<T>from - the (inclusive) low cutoff point
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
public java.util.NavigableSet<T> tailSet(T from,
boolean inclusive)
inclusive is true) 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.
tailSet in interface java.util.NavigableSet<T>from - the low cutoff point.inclusive - true if from should be included.
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 elementspublic T ceiling(T e)
null if there is
no such element.
ceiling in interface java.util.NavigableSet<T>e - the element relative to the returned element.
null if there is
no such element.
ClassCastException - if the specified element can not
be compared with those in the map.
NullPointerException - if the element is null
and this set either uses natural
ordering or a comparator that does
not permit null elements.public Iterator<T> descendingIterator()
descendingSet().iterator().
descendingIterator in interface java.util.NavigableSet<T>public java.util.NavigableSet<T> descendingSet()
Iterator.remove() operation)
result in undefined behaviour from the iteration. The ordering
of the descending set is the same as for a set with a
Comparator given by Collections.reverseOrder(),
and calling descendingSet() on the descending set itself
results in a view equivalent to the original set.
descendingSet in interface java.util.NavigableSet<T>public T floor(T e)
null if there is
no such element.
floor in interface java.util.NavigableSet<T>e - the element relative to the returned element.
null if there is
no such element.
ClassCastException - if the specified element can not
be compared with those in the map.
NullPointerException - if the element is null
and this set either uses natural
ordering or a comparator that does
not permit null elements.public T higher(T e)
null if there is
no such element.
higher in interface java.util.NavigableSet<T>e - the element relative to the returned element.
null if there is
no such element.
ClassCastException - if the specified element can not
be compared with those in the map.
NullPointerException - if the element is null
and this set either uses natural
ordering or a comparator that does
not permit null elements.public T lower(T e)
null if there is
no such element.
lower in interface java.util.NavigableSet<T>e - the element relative to the returned element.
null if there is
no such element.
ClassCastException - if the specified element can not
be compared with those in the map.
NullPointerException - if the element is null
and this set either uses natural
ordering or a comparator that does
not permit null elements.public T pollFirst()
null if the map is empty.
pollFirst in interface java.util.NavigableSet<T>null if the
map is empty.public T pollLast()
null if the map is empty.
pollLast in interface java.util.NavigableSet<T>null if the
map is empty.
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||