|
Préférences
Moteurs de recherche
|
|||||||||||||||||||||||||||||||||||||||||||||||
JavaTM 2 Platform Std. Ed. v1.5.0
java.util
|
Constructor Summary | |
---|---|
TreeSet()
Constructs a new, empty set, sorted according to the elements' natural order. |
|
TreeSet(Collection<? extends E> c)
Constructs a new set containing the elements in the specified collection, sorted according to the elements' natural order. |
|
TreeSet(Comparator<? super E> c)
Constructs a new, empty set, sorted according to the specified comparator. |
|
TreeSet(SortedSet<E> s)
Constructs a new set containing the same elements as the specified sorted set, sorted according to the same ordering. |
Method Summary | |
---|---|
boolean |
add(E o)
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. |
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 this sorted set, or null if this tree set uses its elements natural ordering. |
boolean |
contains(Object o)
Returns true if this set contains the specified element. |
E |
first()
Returns the first (lowest) element currently in this sorted set. |
SortedSet<E> |
headSet(E toElement)
Returns a view of the portion of this set whose elements are strictly less than toElement. |
boolean |
isEmpty()
Returns true if this set contains no elements. |
Iterator<E> |
iterator()
Returns an iterator over the elements in this set. |
E |
last()
Returns the last (highest) element currently in this sorted set. |
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 toElement)
Returns a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive. |
SortedSet<E> |
tailSet(E fromElement)
Returns a view of the portion of this set whose elements are greater than or equal to fromElement. |
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()
Comparable
public TreeSet(Comparator<? super E> c)
c
- the comparator that will be used to sort this set. A
null value indicates that the elements' natural
ordering should be used.public TreeSet(Collection<? extends E> c)
c
- The elements that will comprise the new set.
ClassCastException
- if the keys in the specified collection are
not comparable, or are not mutually comparable.
NullPointerException
- if the specified collection is null.public TreeSet(SortedSet<E> s)
s
- sorted set whose elements will comprise the new set.
NullPointerException
- if the specified sorted set is null.Method Detail |
---|
public Iterator<E> iterator()
public int size()
size
in interface Collection<E>
size
in interface Set<E>
size
in class AbstractCollection<E>
public boolean isEmpty()
isEmpty
in interface Collection<E>
isEmpty
in interface Set<E>
isEmpty
in class AbstractCollection<E>
public boolean contains(Object o)
contains
in interface Collection<E>
contains
in interface Set<E>
contains
in class AbstractCollection<E>
o
- the object to be checked for containment in this set.
ClassCastException
- if the specified object cannot be compared
with the elements currently in the set.public boolean add(E o)
add
in interface Collection<E>
add
in interface Set<E>
add
in class AbstractCollection<E>
o
- element to be added to this set.
ClassCastException
- if the specified object cannot be compared
with the elements currently in the set.public boolean remove(Object o)
remove
in interface Collection<E>
remove
in interface Set<E>
remove
in class AbstractCollection<E>
o
- object to be removed from this set, if present.
ClassCastException
- if the specified object cannot be compared
with the elements currently in the set.public void clear()
clear
in interface Collection<E>
clear
in interface Set<E>
clear
in class AbstractCollection<E>
public boolean addAll(Collection<? extends E> c)
addAll
in interface Collection<E>
addAll
in interface Set<E>
addAll
in class AbstractCollection<E>
c
- elements to be added
ClassCastException
- if the elements provided cannot be compared
with the elements currently in the set.
NullPointerException
- of the specified collection is null.AbstractCollection.add(Object)
public SortedSet<E> subSet(E fromElement, E toElement)
The sorted 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 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);
fromElement
- low endpoint (inclusive) of the subSet.toElement
- high endpoint (exclusive) of the subSet.
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).
IllegalArgumentException
- if fromElement is greater than
toElement.
NullPointerException
- if fromElement or
toElement is null and this set uses natural
order, or its comparator does not tolerate null
elements.public SortedSet<E> headSet(E toElement)
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.
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 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 that are less than or equal to high:
SortedSet head = s.headSet(high+"\0");
toElement
- high endpoint (exclusive) of the headSet.
ClassCastException
- if toElement is not compatible
with this set's comparator (or, if the set has no comparator,
if toElement does not implement Comparable).
IllegalArgumentException
- if this set is itself a subSet,
headSet, or tailSet, and toElement 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 tolerate null elements.public SortedSet<E> tailSet(E fromElement)
The sorted set returned by this method will throw an IllegalArgumentException if the user attempts to insert an element less than fromElement. 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 successor(lowEndpoint). 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");
fromElement
- low endpoint (inclusive) of the tailSet.
ClassCastException
- if fromElement is not compatible
with this set's comparator (or, if the set has no comparator,
if fromElement does not implement Comparable).
IllegalArgumentException
- if this set is itself a subSet,
headSet, or tailSet, and fromElement 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 tolerate null elements.public Comparator<? super E> comparator()
comparator
in interface SortedSet<E>
public E first()
NoSuchElementException
- sorted set is empty.public E last()
NoSuchElementException
- sorted set is empty.public Object clone()
Cloneable