TreeMap源码导读

1,public class TreeMap<K,V>    extends AbstractMap<K,V>    implements NavigableMap<K,V>, Cloneable, java.io.Serializable{/**     * The comparator used to maintain order in this tree map, or     * null if it uses the natural ordering of its keys.     *     * @serial     */    private final Comparator<? super K> comparator;    private transient Entry<K,V> root = null;    /**     * The number of entries in the tree     */    private transient int size = 0;    /**     * The number of structural modifications to the tree.     */    private transient int modCount = 0;    /**     * Constructs a new, empty tree map, using the natural ordering of its     * keys.  All keys inserted into the map must implement the {@link     * Comparable} interface.  Furthermore, all such keys must be     * <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw     * a {@code ClassCastException} for any keys {@code k1} and     * {@code k2} in the map.  If the user attempts to put a key into the     * map that violates this constraint (for example, the user attempts to     * put a string key into a map whose keys are integers), the     * {@code put(Object key, Object value)} call will throw a     * {@code ClassCastException}.     */    public TreeMap() {        comparator = null;    }    /**     * Constructs a new, empty tree map, ordered according to the given     * comparator.  All keys inserted into the map must be <em>mutually     * comparable</em> by the given comparator: {@code comparator.compare(k1,     * k2)} must not throw a {@code ClassCastException} for any keys     * {@code k1} and {@code k2} in the map.  If the user attempts to put     * a key into the map that violates this constraint, the {@code put(Object     * key, Object value)} call will throw a     * {@code ClassCastException}.     *     * @param comparator the comparator that will be used to order this map.     *        If {@code null}, the {@linkplain Comparable natural     *        ordering} of the keys will be used.     */    public TreeMap(Comparator<? super K> comparator) {        this.comparator = comparator;    }/**     * Associates the specified value with the specified key in this map.     * If the map previously contained a mapping for the key, the old     * value is replaced.     *     * @param key key with which the specified value is to be associated     * @param value value to be associated with the specified key     *     * @return the previous value associated with {@code key}, or     *         {@code null} if there was no mapping for {@code key}.     *         (A {@code null} return can also indicate that the map     *         previously associated {@code null} with {@code key}.)     * @throws ClassCastException if the specified key cannot be compared     *         with the keys currently in the map     * @throws NullPointerException if the specified key is null     *         and this map uses natural ordering, or its comparator     *         does not permit null keys     */    public V put(K key, V value) {        Entry<K,V> t = root;        if (t == null) {            compare(key, key); // type (and possibly null) check            root = new Entry<>(key, value, null);            size = 1;            modCount++;            return null;        }        int cmp;        Entry<K,V> parent;        // split comparator and comparable paths        Comparator<? super K> cpr = comparator;        if (cpr != null) {            do {                parent = t;                cmp = cpr.compare(key, t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }        else {            if (key == null)                throw new NullPointerException();            Comparable<? super K> k = (Comparable<? super K>) key;            do {                parent = t;                cmp = k.compareTo(t.key);                if (cmp < 0)                    t = t.left;                else if (cmp > 0)                    t = t.right;                else                    return t.setValue(value);            } while (t != null);        }        Entry<K,V> e = new Entry<>(key, value, parent);        if (cmp < 0)            parent.left = e;        else            parent.right = e;        fixAfterInsertion(e);        size++;        modCount++;        return null;    }    /**     * Removes the mapping for this key from this TreeMap if present.     *     * @param  key key for which mapping should be removed     * @return the previous value associated with {@code key}, or     *         {@code null} if there was no mapping for {@code key}.     *         (A {@code null} return can also indicate that the map     *         previously associated {@code null} with {@code key}.)     * @throws ClassCastException if the specified key cannot be compared     *         with the keys currently in the map     * @throws NullPointerException if the specified key is null     *         and this map uses natural ordering, or its comparator     *         does not permit null keys     */    public V remove(Object key) {        Entry<K,V> p = getEntry(key);        if (p == null)            return null;        V oldValue = p.value;        deleteEntry(p);        return oldValue;    }    /**     * Removes all of the mappings from this map.     * The map will be empty after this call returns.     */    public void clear() {        modCount++;        size = 0;        root = null;    } /**     * Returns the value to which the specified key is mapped,     * or {@code null} if this map contains no mapping for the key.     *     * <p>More formally, if this map contains a mapping from a key     * {@code k} to a value {@code v} such that {@code key} compares     * equal to {@code k} according to the map's ordering, then this     * method returns {@code v}; otherwise it returns {@code null}.     * (There can be at most one such mapping.)     *     * <p>A return value of {@code null} does not <em>necessarily</em>     * indicate that the map contains no mapping for the key; it's also     * possible that the map explicitly maps the key to {@code null}.     * The {@link #containsKey containsKey} operation may be used to     * distinguish these two cases.     *     * @throws ClassCastException if the specified key cannot be compared     *         with the keys currently in the map     * @throws NullPointerException if the specified key is null     *         and this map uses natural ordering, or its comparator     *         does not permit null keys     */    public V get(Object key) {        Entry<K,V> p = getEntry(key);        return (p==null ? null : p.value);    } /**     * Returns this map's entry for the given key, or {@code null} if the map     * does not contain an entry for the key.     *     * @return this map's entry for the given key, or {@code null} if the map     *         does not contain an entry for the key     * @throws ClassCastException if the specified key cannot be compared     *         with the keys currently in the map     * @throws NullPointerException if the specified key is null     *         and this map uses natural ordering, or its comparator     *         does not permit null keys     */    final Entry<K,V> getEntry(Object key) {        // Offload comparator-based version for sake of performance        if (comparator != null)            return getEntryUsingComparator(key);        if (key == null)            throw new NullPointerException();        Comparable<? super K> k = (Comparable<? super K>) key;        Entry<K,V> p = root;        while (p != null) {            int cmp = k.compareTo(p.key);            if (cmp < 0)                p = p.left;            else if (cmp > 0)                p = p.right;            else                return p;        }        return null;    }2,static final class Entry<K,V> implements Map.Entry<K,V> {        K key;        V value;        Entry<K,V> left = null;        Entry<K,V> right = null;        Entry<K,V> parent;        boolean color = BLACK;        /**         * Make a new cell with given key, value, and parent, and with         * {@code null} child links, and BLACK color.         */        Entry(K key, V value, Entry<K,V> parent) {            this.key = key;            this.value = value;            this.parent = parent;        }        /**         * Returns the key.         *         * @return the key         */        public K getKey() {            return key;        }        /**         * Returns the value associated with the key.         *         * @return the value associated with the key         */        public V getValue() {            return value;        }        /**         * Replaces the value currently associated with the key with the given         * value.         *         * @return the value associated with the key before this method was         *         called         */        public V setValue(V value) {            V oldValue = this.value;            this.value = value;            return oldValue;        }        public boolean equals(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry<?,?> e = (Map.Entry<?,?>)o;            return valEquals(key,e.getKey()) && valEquals(value,e.getValue());        }        public int hashCode() {            int keyHash = (key==null ? 0 : key.hashCode());            int valueHash = (value==null ? 0 : value.hashCode());            return keyHash ^ valueHash;        }        public String toString() {            return key + "=" + value;        }    }