• Home
• com.jtransc
• jtransc-rt
• 0.6.5
• source code
• TreeMap.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

java.util.TreeMap Maven / Gradle / Ivy

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package java.util;

import java.io.*;
import java.io.ObjectInputStream.GetField;

import static java.util.TreeMap.Bound.*;
import static java.util.TreeMap.Relation.*;

/**
 * A map whose entries are sorted by their keys. All optional operations such as
 * {@link #put} and {@link #remove} are supported.
 *
 * 
This map sorts keys using either a user-supplied comparator or the key's
 * natural order:
 * 

 *   
User supplied comparators must be able to compare any pair of keys in
 *       this map. If a user-supplied comparator is in use, it will be returned
 *       by {@link #comparator}.
 *   
If no user-supplied comparator is supplied, keys will be sorted by
 *       their natural order. Keys must be mutually comparable: they must
 *       implement {@link Comparable} and {@link Comparable#compareTo
 *       compareTo()} must be able to compare each key with any other key in
 *       this map. In this case {@link #comparator} will return null.
 * 
 * With either a comparator or a natural ordering, comparisons should be
 * consistent with equals. An ordering is consistent with equals if for
 * every pair of keys {@code a} and {@code b}, {@code a.equals(b)} if and only
 * if {@code compare(a, b) == 0}.
 *
 * 
When the ordering is not consistent with equals the behavior of this
 * class is well defined but does not honor the contract specified by {@link
 * Map}. Consider a tree map of case-insensitive strings, an ordering that is
 * not consistent with equals: 
   {@code
 *   TreeMap map = new TreeMap(String.CASE_INSENSITIVE_ORDER);
 *   map.put("a", "android");
 *
 *   // The Map API specifies that the next line should print "null" because
 *   // "a".equals("A") is false and there is no mapping for upper case "A".
 *   // But the case insensitive ordering says compare("a", "A") == 0. TreeMap
 *   // uses only comparators/comparable on keys and so this prints "android".
 *   System.out.println(map.get("A"));
 * }
 *
 * @since 1.2
 */
public class TreeMap extends AbstractMap
        implements SortedMap, NavigableMap, Cloneable, Serializable {

    @SuppressWarnings("unchecked") // to avoid Comparable>>
    private static final Comparator NATURAL_ORDER = new Comparator() {
        public int compare(Comparable a, Comparable b) {
            return a.compareTo(b);
        }
    };

    Comparator comparator;
    Node root;
    int size = 0;
    int modCount = 0;

    /**
     * Create a natural order, empty tree map whose keys must be mutually
     * comparable and non-null.
     */
    @SuppressWarnings("unchecked") // unsafe! this assumes K is comparable
    public TreeMap() {
        this.comparator = (Comparator) NATURAL_ORDER;
    }

    /**
     * Create a natural order tree map populated with the key/value pairs of
     * {@code copyFrom}. This map's keys must be mutually comparable and
     * non-null.
     *
     * 
Even if {@code copyFrom} is a {@code SortedMap}, the constructed map
     * will not use {@code copyFrom}'s ordering. This
     * constructor always creates a naturally-ordered map. Because the {@code
     * TreeMap} constructor overloads are ambiguous, prefer to construct a map
     * and populate it in two steps: 
   {@code
     *   TreeMap customOrderedMap
     *       = new TreeMap(copyFrom.comparator());
     *   customOrderedMap.putAll(copyFrom);
     * }
     */
    public TreeMap(Map copyFrom) {
        this();
        for (Entry entry : copyFrom.entrySet()) {
            putInternal(entry.getKey(), entry.getValue());
        }
    }

    /**
     * Create a tree map ordered by {@code comparator}. This map's keys may only
     * be null if {@code comparator} permits.
     *
     * @param comparator the comparator to order elements with, or {@code null} to use the natural
     * ordering.
     */
    @SuppressWarnings("unchecked") // unsafe! if comparator is null, this assumes K is comparable
    public TreeMap(Comparator comparator) {
        if (comparator != null) {
            this.comparator = comparator;
        } else {
            this.comparator = (Comparator) NATURAL_ORDER;
        }
    }

    /**
     * Create a tree map with the ordering and key/value pairs of {@code
     * copyFrom}. This map's keys may only be null if the {@code copyFrom}'s
     * ordering permits.
     *
     * 
The constructed map will always use {@code
     * copyFrom}'s ordering. Because the {@code TreeMap} constructor overloads
     * are ambiguous, prefer to construct a map and populate it in two steps:
     * 
   {@code
     *   TreeMap customOrderedMap
     *       = new TreeMap(copyFrom.comparator());
     *   customOrderedMap.putAll(copyFrom);
     * }
     */
    @SuppressWarnings("unchecked") // if copyFrom's keys are comparable this map's keys must be also
    public TreeMap(SortedMap copyFrom) {
        Comparator sourceComparator = copyFrom.comparator();
        if (sourceComparator != null) {
            this.comparator = sourceComparator;
        } else {
            this.comparator = (Comparator) NATURAL_ORDER;
        }
        for (Entry entry : copyFrom.entrySet()) {
            putInternal(entry.getKey(), entry.getValue());
        }
    }

    @Override public Object clone() {
        try {
            @SuppressWarnings("unchecked") // super.clone() must return the same type
				TreeMap map = (TreeMap) super.clone();
            map.root = root != null ? root.copy(null) : null;
            map.entrySet = null;
            map.keySet = null;
            return map;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    @Override public int size() {
        return size;
    }

    @Override public boolean isEmpty() {
        return size == 0;
    }

    @Override public V get(Object key) {
        Entry entry = findByObject(key);
        return entry != null ? entry.getValue() : null;
    }

    @Override public boolean containsKey(Object key) {
        return findByObject(key) != null;
    }

    @Override public V put(K key, V value) {
        return putInternal(key, value);
    }

    @Override public void clear() {
        root = null;
        size = 0;
        modCount++;
    }

    @Override public V remove(Object key) {
        Node node = removeInternalByKey(key);
        return node != null ? node.value : null;
    }

    /*
     * AVL methods
     */

    enum Relation {
        LOWER,
        FLOOR,
        EQUAL,
        CREATE,
        CEILING,
        HIGHER;

        /**
         * Returns a possibly-flipped relation for use in descending views.
         *
         * @param ascending false to flip; true to return this.
         */
        Relation forOrder(boolean ascending) {
            if (ascending) {
                return this;
            }

            switch (this) {
                case LOWER:
                    return HIGHER;
                case FLOOR:
                    return CEILING;
                case EQUAL:
                    return EQUAL;
                case CEILING:
                    return FLOOR;
                case HIGHER:
                    return LOWER;
                default:
                    throw new IllegalStateException();
            }
        }
    }

    V putInternal(K key, V value) {
        Node created = find(key, Relation.CREATE);
        V result = created.value;
        created.value = value;
        return result;
    }

    /**
     * Returns the node at or adjacent to the given key, creating it if requested.
     *
     * @throws ClassCastException if {@code key} and the tree's keys aren't mutually comparable.
     */
    Node find(K key, Relation relation) {
        if (root == null) {
            if (comparator == NATURAL_ORDER && !(key instanceof Comparable)) {
                throw new ClassCastException(key.getClass().getName() + " is not Comparable"); // NullPointerException ok
            }
            if (relation == Relation.CREATE) {
                root = new Node(null, key);
                size = 1;
                modCount++;
                return root;
            } else {
                return null;
            }
        }

        /*
         * Micro-optimization: avoid polymorphic calls to Comparator.compare().
         * This is 10% faster for naturally ordered trees.
         */
        @SuppressWarnings("unchecked") // will throw a ClassCastException below if there's trouble
        Comparable