/* * @(#)TreeSet.java	1.27 06/10/10 * * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER   *    * This program is free software; you can redistribute it and/or   * modify it under the terms of the GNU General Public License version   * 2 only, as published by the Free Software Foundation.    *    * This program is distributed in the hope that it will be useful, but   * WITHOUT ANY WARRANTY; without even the implied warranty of   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   * General Public License version 2 for more details (a copy is   * included at /legal/license.txt).    *    * You should have received a copy of the GNU General Public License   * version 2 along with this work; if not, write to the Free Software   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA   * 02110-1301 USA    *    * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa   * Clara, CA 95054 or visit www.sun.com if you need additional   * information or have any questions.  * */package java.util;/** * This class implements the <tt>Set</tt> interface, backed by a * <tt>TreeMap</tt> instance.  This class guarantees that the sorted set will * be in ascending element order, sorted according to the <i>natural order</i> * of the elements (see <tt>Comparable</tt>), or by the comparator provided at * set creation time, depending on which constructor is used.<p> * * This implementation provides guaranteed log(n) time cost for the basic * operations (<tt>add</tt>, <tt>remove</tt> and <tt>contains</tt>).<p> * * Note that the ordering maintained by a set (whether or not an explicit * comparator is provided) must be <i>consistent with equals</i> if it is to * correctly implement the <tt>Set</tt> interface.  (See <tt>Comparable</tt> * or <tt>Comparator</tt> for a precise definition of <i>consistent with * equals</i>.)  This is so because the <tt>Set</tt> interface is defined in * terms of the <tt>equals</tt> operation, but a <tt>TreeSet</tt> instance * performs all key comparisons using its <tt>compareTo</tt> (or * <tt>compare</tt>) method, so two keys that are deemed equal by this method * are, from the standpoint of the set, equal.  The behavior of a set * <i>is</i> well-defined even if its ordering is inconsistent with equals; it * just fails to obey the general contract of the <tt>Set</tt> interface.<p> * * <b>Note that this implementation is not synchronized.</b> If multiple * threads access a set concurrently, and at least one of the threads modifies * the set, it <i>must</i> 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 * <tt>Collections.synchronizedSet</tt> method.  This is best done at creation * time, to prevent accidental unsynchronized access to the set: <pre> *     SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...)); * </pre><p> * * The Iterators returned by this class's <tt>iterator</tt> method are * <i>fail-fast</i>: if the set is modified at any time after the iterator is * created, in any way except through the iterator's own <tt>remove</tt> * method, the iterator will throw a <tt>ConcurrentModificationException</tt>. * 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. * * <p>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 <tt>ConcurrentModificationException</tt> on a best-effort basis.  * Therefore, it would be wrong to write a program that depended on this * exception for its correctness:   <i>the fail-fast behavior of iterators * should be used only to detect bugs.</i><p> * * This class is a member of the  * <a href="{@docRoot}/../guide/collections/index.html"> * Java Collections Framework</a>. * * @author  Josh Bloch * @version 1.20, 02/02/00 * @see	    Collection * @see	    Set * @see	    HashSet * @see     Comparable * @see     Comparator * @see	    Collections#synchronizedSortedSet(SortedSet) * @see	    TreeMap * @since   1.2 */public class TreeSet extends AbstractSet		     implements SortedSet, Cloneable, java.io.Serializable{    private transient SortedMap m;	 // The backing Map    private transient Set      	keySet;  // The keySet view of the backing Map    // Dummy value to associate with an Object in the backing Map    private static final Object PRESENT = new Object();    /**     * Constructs a set backed by the specified sorted map.     */    private TreeSet(SortedMap m) {        this.m = m;        keySet = m.keySet();    }    /**     * Constructs a new, empty set, sorted according to the elements' natural     * order.  All elements inserted into the set must implement the     * <tt>Comparable</tt> interface.  Furthermore, all such elements must be     * <i>mutually comparable</i>: <tt>e1.compareTo(e2)</tt> must not throw a     * <tt>ClassCastException</tt> for any elements <tt>e1</tt> and     * <tt>e2</tt> 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     * <tt>add(Object)</tt> call will throw a <tt>ClassCastException</tt>.     *      * @see Comparable     */    public TreeSet() {	this(new TreeMap());    }    /**     * Constructs a new, empty set, sorted according to the specified     * comparator.  All elements inserted into the set must be <i>mutually     * comparable</i> by the specified comparator: <tt>comparator.compare(e1,     * e2)</tt> must not throw a <tt>ClassCastException</tt> for any elements     * <tt>e1</tt> and <tt>e2</tt> in the set.  If the user attempts to add     * an element to the set that violates this constraint, the     * <tt>add(Object)</tt> call will throw a <tt>ClassCastException</tt>.     *     * @param c the comparator that will be used to sort this set.  A     *        <tt>null</tt> value indicates that the elements' <i>natural     *        ordering</i> should be used.     */    public TreeSet(Comparator c) {	this(new TreeMap(c));    }    /**     * Constructs a new set containing the elements in the specified     * collection, sorted according to the elements' <i>natural order</i>.     * All keys inserted into the set must implement the <tt>Comparable</tt>     * interface.  Furthermore, all such keys must be <i>mutually     * comparable</i>: <tt>k1.compareTo(k2)</tt> must not throw a     * <tt>ClassCastException</tt> for any elements <tt>k1</tt> and     * <tt>k2</tt> in the set.     *     * @param c The elements that will comprise the new set.     *     * @throws ClassCastException if the keys in the specified collection are     *         not comparable, or are not mutually comparable.     * @throws NullPointerException if the specified collection is null.     */    public TreeSet(Collection c) {        this();        addAll(c);            }    /**     * Constructs a new set containing the same elements as the specified     * sorted set, sorted according to the same ordering.     *     * @param s sorted set whose elements will comprise the new set.     * @throws NullPointerException if the specified sorted set is null.     */    public TreeSet(SortedSet s) {        this(s.comparator());	addAll(s);    }    /**     * Returns an iterator over the elements in this set.  The elements     * are returned in ascending order.     *     * @return an iterator over the elements in this set.     */    public Iterator iterator() {	return keySet.iterator();    }    /**     * Returns the number of elements in this set (its cardinality).     *     * @return the number of elements in this set (its cardinality).     */    public int size() {	return m.size();    }    /**     * Returns <tt>true</tt> if this set contains no elements.     *     * @return <tt>true</tt> if this set contains no elements.     */    public boolean isEmpty() {	return m.isEmpty();    }    /**     * Returns <tt>true</tt> if this set contains the specified element.     *     * @param o the object to be checked for containment in this set.     * @return <tt>true</tt> if this set contains the specified element.     *      * @throws ClassCastException if the specified object cannot be compared     * 		  with the elements currently in the set.     */    public boolean contains(Object o) {	return m.containsKey(o);    }    /**     * Adds the specified element to this set if it is not already present.     *     * @param o element to be added to this set.     * @return <tt>true</tt> if the set did not already contain the specified     *         element.     *      * @throws ClassCastException if the specified object cannot be compared     * 		  with the elements currently in the set.     */    public boolean add(Object o) {	return m.put(o, PRESENT)==null;    }    /**     * Removes the specified element from this set if it is present.     *     * @param o object to be removed from this set, if present.     * @return <tt>true</tt> if the set contained the specified element.     *      * @throws ClassCastException if the specified object cannot be compared     * 		  with the elements currently in the set.     */    public boolean remove(Object o) {	return m.remove(o)==PRESENT;    }    /**     * Removes all of the elements from this set.     */    public void clear() {	m.clear();    }    /**     * Adds all of the elements in the specified collection to this set.     *     * @param c elements to be added