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.
*
* @author Jon Zeppieri
* @author Bryce McKinlay
* @author Eric Blake to. The returned set is backed by the original, so changes
* in one appear in the other. The subset will throw an
* {@link 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.
*
* @param to the (exclusive) cutoff point
* @return 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)
* @throws NullPointerException if to is null, but the comparator does not
* tolerate null elements
*/
public SortedSet headSet(Object to)
{
return new TreeSet(map.headMap(to));
}
/**
* Returns true if this Set has size 0, false otherwise.
*
* @return true if the set is empty
*/
public boolean isEmpty()
{
return map.isEmpty();
}
/**
* Returns in Iterator over the elements in this TreeSet, which traverses
* in ascending order.
*
* @return an iterator
*/
public Iterator iterator()
{
return map.keySet().iterator();
}
/**
* Returns the last (by order) element in this Set.
*
* @return the last element
* @throws NoSuchElementException if the set is empty
*/
public Object last()
{
return map.lastKey();
}
/**
* If the supplied Object is in this Set, it is removed, and true is
* returned; otherwise, false is returned.
*
* @param obj the Object to remove from this Set
* @return true if the set was modified
* @throws ClassCastException if obj cannot be compared to set elements
*/
public boolean remove(Object obj)
{
return map.remove(obj) != null;
}
/**
* Returns the number of elements in this Set
*
* @return the set size
*/
public int size()
{
return map.size();
}
/**
* 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 {@link 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.
*
* @param from the (inclusive) low cutoff point
* @param to the (exclusive) high cutoff point
* @return a view of the set between the cutoffs
* @throws ClassCastException if either cutoff is not compatible with
* the comparator (or is not Comparable, for natural ordering)
* @throws NullPointerException if from or to is null, but the comparator
* does not tolerate null elements
* @throws IllegalArgumentException if from is greater than to
*/
public SortedSet subSet(Object from, Object to)
{
return new TreeSet(map.subMap(from, to));
}
/**
* 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
* {@link 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.
*
* @param from the (inclusive) low cutoff point
* @return 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)
* @throws NullPointerException if from is null, but the comparator
* does not tolerate null elements
*/
public SortedSet tailSet(Object from)
{
return new TreeSet(map.tailMap(from));
}
/**
* Serializes this object to the given stream.
*
* @param s the stream to write to
* @throws IOException if the underlying stream fails
* @serialData the comparator (Object), followed by the set size
* (int), the the elements in sorted order (Object)
*/
private void writeObject(ObjectOutputStream s) throws IOException
{
s.defaultWriteObject();
Iterator itr = map.keySet().iterator();
int pos = map.size();
s.writeObject(map.comparator());
s.writeInt(pos);
while (--pos >= 0)
s.writeObject(itr.next());
}
/**
* Deserializes this object from the given stream.
*
* @param s the stream to read from
* @throws ClassNotFoundException if the underlying stream fails
* @throws IOException if the underlying stream fails
* @serialData the comparator (Object), followed by the set size
* (int), the the elements in sorted order (Object)
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
Comparator comparator = (Comparator) s.readObject();
int size = s.readInt();
map = new TreeMap(comparator);
((TreeMap) map).putFromObjStream(s, size, false);
}
}