TopBlend:
Here is the
first difference.
There are 134 differences.
is old.
is new.
java.util
Class TreeSet<E>
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E>
java.util.TreeSet<E>
-
-
Type Parameters:
All Implemented Interfaces:
-
E - the type of elements maintained by this set
Serializable
,
Cloneable
,
Iterable
<E>,
Collection
<E>,
Set
<E>,
SortedSet
<E>
-
All Implemented Interfaces:
-
Serializable
,
Cloneable
,
Iterable
<E>,
Collection
<E>,
NavigableSet
<E>,
Set
<E>,
SortedSet
<E>
-
public class TreeSet<E>
- extends AbstractSet<E>
- implements NavigableSet
SortedSet<E>, Cloneable, Serializable
A
NavigableSet
implementation based on a
TreeMap
. The elements are ordered using their
natural ordering
, or by a
Comparator
provided at set creation time, depending on which constructor is used.
This class implements the
Set
interface, backed by a
TreeMap
instance. This class guarantees that the sorted set will be in ascending element order, sorted according to the
natural order
of the elements (see
Comparable
), or by the comparator provided at set creation time, depending on which constructor is used.
This implementation provides guaranteed log(n) time cost for the basic operations (
add
,
remove
and
contains
).
Note that the ordering maintained by a set (whether or not an explicit comparator is provided) must be
consistent with equals
if it is to correctly implement the
Set
interface. (See
Comparable
or
Comparator
for a precise definition of
consistent with equals
.) This is so because the
Set
interface is defined in terms of the
equals
operation, but a
TreeSet
instance performs all
element
key
comparisons using its
compareTo
(or
compare
) method, so two
elements
keys
that are deemed equal by this method are, from the standpoint of the set, equal. The behavior of a set
is
well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the
Set
interface.
Note that this implementation is not synchronized.
If multiple threads access a
tree
set concurrently, and at least one of the threads modifies the set, it
must
be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the set. If no such object exists, the set should be "wrapped" using the
Collections.synchronizedSortedSet
Collections.synchronizedSet
method. This is best done at creation time, to prevent accidental unsynchronized access to the set:
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
The
iterators
Iterators
returned by this class's
iterator
method are
fail-fast
: if the set 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
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.
Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw
ConcurrentModificationException
on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness:
the fail-fast behavior of iterators should be used only to detect bugs.
This class is a member of the
Java Collections Framework
.
-
Since:
-
1.2
-
See Also:
-
Collection
,
Set
,
HashSet
,
Comparable
,
Comparator
,
Collections.synchronizedSortedSet(SortedSet)
,
TreeMap
,
Serialized Form
Constructor Summary
|
TreeSet
()
Constructs a new, empty
tree
set, sorted according to the
elements'
natural
ordering of its elements.
order.
|
TreeSet
(
Collection
<? extends
E
Constructs a new
tree
set containing the elements in the specified collection, sorted according to the
elements'
natural
ordering
order
of its elements.
.
|
TreeSet
(
Comparator
<? super
E
Constructs a new, empty
tree
set, sorted according to the specified comparator. |
TreeSet
(
SortedSet
<
E
Constructs a new
tree
set containing the same elements
and using the same ordering
as the specified sorted
set.
set, sorted according to the same ordering.
|
Method Summary
|
boolean |
add
(
E
Adds the specified element to this set if it is not already present. |
boolean |
addAll
(
Collection
<? extends
E
> c)
Adds all of the elements in the specified collection to this set. |
E
|
ceiling
(
E
Returns the least element in this set greater than or equal to the given element, or
null
if there is no such element.
|
void |
clear
()
Removes all of the elements from this set. |
Object
|
clone
()
Returns a shallow copy of this
TreeSet
instance. |
Comparator
<? super
E
|
comparator
()
Returns the comparator used to order
the elements in
this
sorted
set, or
null
if this
tree
set uses
the
natural ordering
its elements natural ordering.
|
boolean |
contains
(
Object
o)
Returns
true
if this set contains the specified element. |
Iterator
<
E
|
descendingIterator
first
()
Returns
an iterator over
the
elements
first (lowest) element currently
in this
set in descending order.
sorted set.
|
E
|
first
()
Returns the first (lowest) element currently in this set.
|
SortedSet
<
E
|
headSet
(
E
Returns a view of the portion of this set whose elements are strictly less than
toElement
.
|
E
|
floor
(
E
Returns the greatest element in this set less than or equal to the given element, or
null
if there is no such element.
|
SortedSet
<
E
|
headSet
(
E
Equivalent to
navigableHeadSet(E)
SortedSet
interface.
|
E
|
higher
(
E
Returns the least element in this set strictly greater than the given element, or
null
if there is no such element.
|
boolean |
isEmpty
()
Returns
true
if this set contains no elements. |
Iterator
<
E
|
iterator
()
Returns an iterator over the elements in this
set in ascending order.
set.
|
E
|
last
()
Returns the last (highest) element currently in this
sorted
set. |
E
|
lower
(
E
Returns the greatest element in this set strictly less than the given element, or
null
if there is no such element.
|
NavigableSet
<
E
|
navigableHeadSet
(
E
Returns a view of the portion of this set whose elements are strictly less than
toElement
.
|
NavigableSet
<
E
|
navigableSubSet
(
E
fromElement,
E
Returns a view of the portion of this set whose elements range from
fromElement
, inclusive, to
toElement
, exclusive.
|
NavigableSet
<
E
|
navigableTailSet
(
E
Returns a view of the portion of this set whose elements are greater than or equal to
fromElement
.
|
E
|
pollFirst
()
Retrieves and removes the first (lowest) element, or returns
null
if this set is empty.
|
E
|
pollLast
()
Retrieves and removes the last (highest) element, or returns
null
if this set is empty.
|
boolean |
remove
(
Object
o)
Removes the specified element from this set if it is present. |
int |
size
()
Returns the number of elements in this set (its cardinality). |
SortedSet
<
E
|
subSet
(
E
fromElement,
E
Equivalent
Returns a view of the portion of this set whose elements range from
fromElement
, inclusive,
to
navigableSubSet(E, E)
SortedSet
toElement
interface.
, exclusive.
|
SortedSet
<
E
|
tailSet
(
E
Equivalent
Returns a view of the portion of this set whose elements are greater than or equal
to
navigableTailSet(E)
SortedSet
fromElement
interface.
.
|
TreeSet
public TreeSet()
-
Constructs a new, empty
tree
set, sorted according to the
elements'
natural
ordering of its elements.
order.
All elements inserted into the set must implement the
Comparable
Comparable
interface. Furthermore, all such elements must be
mutually comparable
:
e1.compareTo(e2)
must not throw a
ClassCastException
for any elements
e1
and
e2
in the set. If the user attempts to add an element to the set that violates this constraint (for example, the user attempts to add a string element to a set whose elements are integers), the
add(Object)
call will throw a
ClassCastException
.
-
See Also:
-
Comparable
TreeSet
public TreeSet(Comparator<? super E> comparator) > c)
-
Constructs a new, empty
tree
set, sorted according to the specified comparator. All elements inserted into the set must be
mutually comparable
by the specified comparator:
comparator.compare(e1, e2)
must not throw a
ClassCastException
for any elements
e1
and
e2
in the set. If the user attempts to add an element to the set that violates this constraint, the
add(Object)
call will throw a
ClassCastException
.
-
Parameters:
-
comparator
c
- the comparator that will be used to
order
sort
this set.
If
A
null
, the
natural ordering
of the elements will be used.
value indicates that the elements'
natural ordering
should be used.
TreeSet
public TreeSet(Collection<? extends E> c)
-
Constructs a new
tree
set containing the elements in the specified collection, sorted according to the
elements'
natural
ordering
order
of its elements.
.
All
elements
keys
inserted into the set must implement the
Comparable
Comparable
interface. Furthermore, all such
elements
keys
must be
mutually comparable
:
e1.compareTo(e2)
k1.compareTo(k2)
must not throw a
ClassCastException
for any elements
e1
k1
and
e2
k2
in the set.
-
Parameters:
-
c -
collection whose
The
elements
that
will comprise the new
set
set.
-
Throws:
-
ClassCastException
- if the
elements
keys
in
c
the specified collection
are not
Comparable
,
comparable,
or are not mutually
comparable
comparable.
-
NullPointerException
- if the specified collection is
null
null.
TreeSet
public TreeSet(SortedSet<E> s)
-
Constructs a new
tree
set containing the same elements
and using the same ordering
as the specified sorted
set.
set, sorted according to the same ordering.
-
Parameters:
-
s - sorted set whose elements will comprise the new
set
set.
-
Throws:
-
NullPointerException
- if the specified sorted set is
null
null.
iterator
public Iterator<E> iterator()
-
Returns an iterator over the elements in this
set
set. The elements are returned
in ascending order.
-
-
Specified by:
-
iterator
in interface
Iterable
<
E
>
-
Specified by:
-
iterator
in interface
Collection
<
E
>
-
Specified by:
-
iterator
in interface
NavigableSet
<
E
>
-
Specified by:
-
iterator
in interface
Set
<
E
>
-
Specified by:
-
iterator
in class
AbstractCollection
<
E
>
-
-
Returns:
-
an iterator over the elements in this
set in ascending order
set.
descendingIterator
public Iterator< E> descendingIterator ()
-
Returns an iterator over the elements in this set in descending order.
-
-
Specified by:
-
descendingIterator
in interface
NavigableSet
<
E
>
-
-
Returns:
-
an iterator over the elements in this set in descending order
-
Since:
-
1.6
size
public int size()
-
Returns the number of elements in this set (its cardinality).
-
-
Specified by:
-
size
in interface
Collection
<
E
>
-
Specified by:
-
size
in interface
Set
<
E
>
-
Specified by:
-
size
in class
AbstractCollection
<
E
>
-
-
Returns:
-
the number of elements in this set (its
cardinality)
cardinality).
isEmpty
public boolean isEmpty()
-
Returns
true
if this set contains no elements.
-
-
Specified by:
-
isEmpty
in interface
Collection
<
E
>
-
Specified by:
-
isEmpty
in interface
Set
<
E
>
-
Overrides:
-
isEmpty
in class
AbstractCollection
<
E
>
-
-
Returns:
-
true
if this set contains no
elements
elements.
contains
public boolean contains(Object o)
-
Returns
true
if this set contains the specified element.
More formally, returns
true
if and only if this set contains an element
e
such that
(o==null ? e==null : o.equals(e))
.
-
-
Specified by:
-
contains
in interface
Collection
<
E
>
-
Specified by:
-
contains
in interface
Set
<
E
>
-
Overrides:
-
contains
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
o -
the
object to be checked for containment in this
set
set.
-
Returns:
-
true
if this set contains the specified
element
element.
-
Throws:
-
ClassCastException
- if the specified object cannot be compared with the elements currently in the
set
-
NullPointerException
- if the specified element is null and this set uses natural ordering, or its comparator does not permit null elements
set.
add
public boolean add(E e) o)
-
Adds the specified element to this set if it is not already present.
More formally, adds the specified element
e
to this set if the set contains no element
e2
such that
(e==null ? e2==null : e.equals(e2))
. If this set already contains the element, the call leaves the set unchanged and returns
false
.
-
-
Specified by:
-
add
in interface
Collection
<
E
>
-
Specified by:
-
add
in interface
Set
<
E
>
-
Overrides:
-
add
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
e
o
- element to be added to this
set
set.
-
Returns:
-
true
if
this
the
set did not already contain the specified
element
element.
-
Throws:
-
ClassCastException
- if the specified object cannot be compared with the elements currently in
this set
-
NullPointerException
- if
the
specified element is null and this set uses natural ordering, or its comparator does not permit null elements
set.
remove
public boolean remove(Object o)
-
Removes the specified element from this set if it is present.
More formally, removes an element
e
such that
(o==null ? e==null : o.equals(e))
, if this set contains such an element. Returns
true
if this set contained the element (or equivalently, if this set changed as a result of the call). (This set will not contain the element once the call returns.)
-
-
Specified by:
-
remove
in interface
Collection
<
E
>
-
Specified by:
-
remove
in interface
Set
<
E
>
-
Overrides:
-
remove
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
o - object to be removed from this set, if
present
present.
-
Returns:
-
true
if
this
the
set contained the specified
element
element.
-
Throws:
-
ClassCastException
- if the specified object cannot be compared with the elements currently in
this set
-
NullPointerException
- if
the
specified element is null and this set uses natural ordering, or its comparator does not permit null elements
set.
clear
public void clear()
-
Removes all of the elements from this set.
The set will be empty after this call returns.
-
-
Specified by:
-
clear
in interface
Collection
<
E
>
-
Specified by:
-
clear
in interface
Set
<
E
>
-
Overrides:
-
clear
in class
AbstractCollection
<
E
>
-
addAll
public boolean addAll(Collection<? extends E> c)
-
Adds all of the elements in the specified collection to this set.
-
-
Specified by:
-
addAll
in interface
Collection
<
E
>
-
Specified by:
-
addAll
in interface
Set
<
E
>
-
Overrides:
-
addAll
in class
AbstractCollection
<
E
>
-
-
Parameters:
-
c -
collection containing
elements to be added
to this set
-
Returns:
-
true
if this set changed as a result of the
call
call.
-
Throws:
-
ClassCastException
- if the elements provided cannot be compared with the elements currently in the
set
set.
-
NullPointerException
- if the specified collection is null or if any element is null and this set uses natural ordering, or its comparator does not permit null elements
- of the specified collection is null.
-
See Also:
-
AbstractCollection.add(Object)
navigableSubSet
public NavigableSet< E> navigableSubSet ( E fromElement,
E toElement)
-
Description copied from interface:
NavigableSet
-
Returns a view of the portion of this set whose elements range from
fromElement
, inclusive, to
toElement
, exclusive. (If
fromElement
and
toElement
are equal, the returned set is empty.) The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
The returned set will throw an
IllegalArgumentException
on an attempt to insert an element outside its range.
-
-
Specified by:
-
navigableSubSet
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
fromElement - low endpoint (inclusive) of the returned set
-
toElement - high endpoint (exclusive) of the returned set
-
Returns:
-
a view of the portion of this set whose elements range from
fromElement
, inclusive, to
toElement
, exclusive
-
Throws:
-
ClassCastException
- if
fromElement
and
toElement
cannot be compared to one another using this set's comparator (or, if the set has no comparator, using natural ordering). Implementations may, but are not required to, throw this exception if
fromElement
or
toElement
cannot be compared to elements currently in the set.
-
NullPointerException
- if
fromElement
or
toElement
is null and this set uses natural ordering, or its comparator does not permit null elements
-
IllegalArgumentException
- if
fromElement
is greater than
toElement
; or if this set itself has a restricted range, and
fromElement
or
toElement
lies outside the bounds of the range.
-
Since:
-
1.6
navigableHeadSet
public NavigableSet< E> navigableHeadSet ( E toElement)
-
Description copied from interface:
NavigableSet
-
Returns a view of the portion of this set whose elements are strictly less than
toElement
. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
The returned set will throw an
IllegalArgumentException
on an attempt to insert an element outside its range.
-
-
Specified by:
-
navigableHeadSet
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
toElement - high endpoint (exclusive) of the returned set
-
Returns:
-
a view of the portion of this set whose elements are strictly less than
toElement
-
Throws:
-
ClassCastException
- if
toElement
is not compatible with this set's comparator (or, if the set has no comparator, if
toElement
does not implement
Comparable
). Implementations may, but are not required to, throw this exception if
toElement
cannot be compared to elements currently in the set.
-
NullPointerException
- if
toElement
is null and this set uses natural ordering, or its comparator does not permit null elements
-
IllegalArgumentException
- if this set itself has a restricted range, and
toElement
lies outside the bounds of the range
-
Since:
-
1.6
navigableTailSet
public NavigableSet< E> navigableTailSet ( E fromElement)
-
Description copied from interface:
NavigableSet
-
Returns a view of the portion of this set whose elements are greater than or equal to
fromElement
. The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
The returned set will throw an
IllegalArgumentException
on an attempt to insert an element outside its range.
-
-
Specified by:
-
navigableTailSet
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
fromElement - low endpoint (inclusive) of the returned set
-
Returns:
-
a view of the portion of this set whose elements are greater than or equal to
fromElement
-
Throws:
-
ClassCastException
- if
fromElement
is not compatible with this set's comparator (or, if the set has no comparator, if
fromElement
does not implement
Comparable
). Implementations may, but are not required to, throw this exception if
fromElement
cannot be compared to elements currently in the set.
-
NullPointerException
- if
fromElement
is null and this set uses natural ordering, or its comparator does not permit null elements
-
IllegalArgumentException
- if this set itself has a restricted range, and
fromElement
lies outside the bounds of the range
-
Since:
-
1.6
subSet
public SortedSet<E> subSet(E fromElement,
E toElement)
-
Equivalent to
navigableSubSet(E, E)
but with a return type conforming to the
SortedSet
interface.
Returns a view of the portion of this set whose elements range from
fromElement
, inclusive, to
toElement
, exclusive. (If
fromElement
and
toElement
are equal, the returned
sorted
set is empty.) The returned
sorted
set is backed by this set, so changes in the returned
sorted
set are reflected in this set, and vice-versa. The returned
sorted
set supports all optional
set operations that this set supports.
Set operations.
The
sorted set
returned
set
by this method
will throw an
IllegalArgumentException
on an attempt
if the user attempts
to insert an element outside
its
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 of a specified value, merely request the subrange from
lowEndpoint
to
successor(highEndpoint)
. For example, suppose that
s
is a sorted set of strings. The following idiom obtains a view containing all of the strings in
s
from
low
to
high
, inclusive:
SortedSet sub = s.subSet(low, high+"\0");
A similar 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:
SortedSet sub = s.subSet(low+"\0", high);
-
-
Specified by:
-
subSet
in interface
SortedSet
<
E
>
-
-
Parameters:
-
fromElement - low endpoint (inclusive) of the
returned set
subSet.
-
toElement - high endpoint (exclusive) of the
returned set
subSet.
-
Returns:
-
a view of the portion of this set whose elements range from
fromElement
, inclusive, to
toElement
,
exclusive
exclusive.
-
Throws:
-
ClassCastException
- if
fromElement
and
toElement
cannot be compared to one another using this set's comparator (or, if the set has no comparator, using natural ordering).
Implementations may, but are not required to, throw this exception if
fromElement
or
toElement
cannot be compared to elements currently in the set.
-
NullPointerException
IllegalArgumentException
- if
fromElement
or
is greater than
toElement
is null and this set uses natural ordering, or its comparator does not permit null elements
.
-
IllegalArgumentException
NullPointerException
- if
fromElement
is greater than
or
toElement
; or if this set itself has a restricted range, and
is
fromElement
null
or
and this set uses natural order, or its comparator does not tolerate
toElement
null
lies outside the bounds of the range
elements.
headSet
public SortedSet<E> headSet(E toElement)
-
Equivalent to
navigableHeadSet(E)
but with a return type conforming to the
Returns a view of the portion of this set whose elements are strictly less than
SortedSet
toElement
interface.
. The returned sorted set is backed by this set, so changes in the returned sorted set are reflected in this set, and vice-versa. The returned sorted set supports all optional set operations.
Returns a view of the portion of this set whose elements are strictly less than
The sorted set returned by this method will throw an
IllegalArgumentException
if the user attempts to insert an element greater than or equal to
toElement
.
The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
The returned set will throw an
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 of a specified value, merely request a headSet bounded by
IllegalArgumentException
successor(highEndpoint)
on an attempt to insert an element outside its range.
. For example, suppose that
s
is a sorted set of strings. The following idiom obtains a view containing all of the strings in
s
that are less than or equal to
high
:
SortedSet head = s.headSet(high+"\0");
-
-
Specified by:
-
headSet
in interface
SortedSet
<
E
>
-
-
Parameters:
-
toElement - high endpoint (exclusive) of the
returned set
headSet.
-
Returns:
-
a view of the portion of this set whose elements are strictly less than
toElement
toElement.
-
Throws:
-
ClassCastException
- if
toElement
is not compatible with this set's comparator (or, if the set has no comparator, if
toElement
does not implement
Comparable
does not implement
Comparable
).
-
IllegalArgumentException
). Implementations may, but are not required to, throw this exception if
- if this set is itself a subSet, headSet, or tailSet, and
toElement
cannot be compared to elements currently in the set.
is not within the specified range of the subSet, headSet, or tailSet.
-
NullPointerException
- if
toElement
is null and this set uses natural ordering, or its comparator does not permit null elements
-
IllegalArgumentException
- if this set itself has a restricted range, and
is
toElement
null
lies outside the bounds of the range
and this set uses natural ordering, or its comparator does not tolerate
null
elements.
tailSet
public SortedSet<E> tailSet(E fromElement)
-
Equivalent to
navigableTailSet(E)
but with a return type conforming to the
Returns a view of the portion of this set whose elements are greater than or equal to
SortedSet
fromElement
interface.
. The returned sorted set is backed by this set, so changes in the returned sorted set are reflected in this set, and vice-versa. The returned sorted set supports all optional set operations.
Returns a view of the portion of this set whose elements are greater than or equal to
The sorted set returned by this method will throw an
IllegalArgumentException
if the user attempts to insert an element less than
fromElement
.
The returned set is backed by this set, so changes in the returned set are reflected in this set, and vice-versa. The returned set supports all optional set operations that this set supports.
The returned set will throw an
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 of a specified value, merely request a tailSet bounded by
IllegalArgumentException
successor(lowEndpoint)
on an attempt to insert an element outside its range.
. For example, suppose that
s
is a sorted set of strings. The following idiom obtains a view containing all of the strings in
s
that are strictly greater than
low
:
SortedSet tail = s.tailSet(low+"\0");
-
-
Specified by:
-
tailSet
in interface
SortedSet
<
E
>
-
-
Parameters:
-
fromElement - low endpoint (inclusive) of the
returned set
tailSet.
-
Returns:
-
a view of the portion of this set whose elements are greater than or equal to
fromElement
.
-
Throws:
-
ClassCastException
- if
fromElement
is not compatible with this set's comparator (or, if the set has no comparator, if
fromElement
does not implement
Comparable
does not implement
Comparable
).
-
IllegalArgumentException
). Implementations may, but are not required to, throw this exception if
- if this set is itself a subSet, headSet, or tailSet, and
fromElement
cannot be compared to elements currently in the set.
is not within the specified range of the subSet, headSet, or tailSet.
-
NullPointerException
- if
fromElement
is null and this set uses natural ordering, or its comparator does not permit null elements
-
IllegalArgumentException
- if this set itself has a restricted range, and
is
fromElement
null
lies outside the bounds of the range
and this set uses natural ordering, or its comparator does not tolerate
null
elements.
comparator
public Comparator<? super E> comparator()
-
Description copied from interface:
SortedSet
-
Returns the comparator used to order
the elements in
this
sorted
set, or
null
if this
tree
set uses
the
natural ordering
of
its
elements.
elements natural ordering.
-
-
Specified by:
-
comparator
in interface
SortedSet
<
E
>
-
-
Returns:
-
the comparator used to order
the elements in
this
sorted
set, or
null
if this
tree
set uses
the natural ordering of
its elements
natural ordering.
first
public E first()
-
Description copied from interface:
SortedSet
-
Returns the first (lowest) element currently in this
sorted
set.
-
-
Specified by:
-
first
in interface
SortedSet
<
E
>
-
-
Returns:
-
the first (lowest) element currently in this
set
sorted set.
-
Throws:
-
NoSuchElementException
-
if this
sorted
set is
empty
empty.
last
public E last()
-
Description copied from interface:
SortedSet
-
Returns the last (highest) element currently in this
sorted
set.
-
-
Specified by:
-
last
in interface
SortedSet
<
E
>
-
-
Returns:
-
the last (highest) element currently in this
set
sorted set.
-
Throws:
-
NoSuchElementException
-
if this
sorted
set is
empty
empty.
lower
public Elower ( E e)
-
Description copied from interface:
NavigableSet
-
Returns the greatest element in this set strictly less than the given element, or
null
if there is no such element.
-
-
Specified by:
-
lower
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
e - the value to match
-
Returns:
-
the greatest element less than
e
, or
null
if there is no such element
-
Throws:
-
ClassCastException
- if the specified element cannot be compared with the elements currently in the set
-
NullPointerException
- if the specified element is null and this set uses natural ordering, or its comparator does not permit null elements
-
Since:
-
1.6
floor
public Efloor ( E e)
-
Description copied from interface:
NavigableSet
-
Returns the greatest element in this set less than or equal to the given element, or
null
if there is no such element.
-
-
Specified by:
-
floor
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
e - the value to match
-
Returns:
-
the greatest element less than or equal to
e
, or
null
if there is no such element
-
Throws:
-
ClassCastException
- if the specified element cannot be compared with the elements currently in the set
-
NullPointerException
- if the specified element is null and this set uses natural ordering, or its comparator does not permit null elements
-
Since:
-
1.6
ceiling
public Eceiling ( E e)
-
Description copied from interface:
NavigableSet
-
Returns the least element in this set greater than or equal to the given element, or
null
if there is no such element.
-
-
Specified by:
-
ceiling
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
e - the value to match
-
Returns:
-
the least element greater than or equal to
e
, or
null
if there is no such element
-
Throws:
-
ClassCastException
- if the specified element cannot be compared with the elements currently in the set
-
NullPointerException
- if the specified element is null and this set uses natural ordering, or its comparator does not permit null elements
-
Since:
-
1.6
higher
public Ehigher ( E e)
-
Description copied from interface:
NavigableSet
-
Returns the least element in this set strictly greater than the given element, or
null
if there is no such element.
-
-
Specified by:
-
higher
in interface
NavigableSet
<
E
>
-
-
Parameters:
-
e - the value to match
-
Returns:
-
the least element greater than
e
, or
null
if there is no such element
-
Throws:
-
ClassCastException
- if the specified element cannot be compared with the elements currently in the set
-
NullPointerException
- if the specified element is null and this set uses natural ordering, or its comparator does not permit null elements
-
Since:
-
1.6
pollFirst
public EpollFirst ()
-
Description copied from interface:
NavigableSet
-
Retrieves and removes the first (lowest) element, or returns
null
if this set is empty.
-
-
Specified by:
-
pollFirst
in interface
NavigableSet
<
E
>
-
-
Returns:
-
the first element, or
null
if this set is empty
-
Since:
-
1.6
pollLast
public EpollLast ()
-
Description copied from interface:
NavigableSet
-
Retrieves and removes the last (highest) element, or returns
null
if this set is empty.
-
-
Specified by:
-
pollLast
in interface
NavigableSet
<
E
>
-
-
Returns:
-
the last element, or
null
if this set is empty
-
Since:
-
1.6
clone
public Object clone()
-
Returns a shallow copy of this
TreeSet
instance. (The elements themselves are not cloned.)
-
-
Overrides:
-
clone
in class
Object
-
-
Returns:
-
a shallow copy of this
set
set.
-
See Also:
-
Cloneable