TreeMap分析

TreeMap是基于红黑树实现的，红黑树是一种特殊的二叉树，百科一下介绍红黑树的性质：
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3 每个叶节点（NIL节点，空节点）是黑色的。
性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
每次插入或者删除时，需要对二叉树进行调整，使得新树也满足红黑树限制。

构造函数 & 描述

1 TreeMap() 

这个构造函数构造一个新的，空的树映射，使用键的自然顺序。

 2 TreeMap(Comparator<? super K> comparator) 

这个构造函数构造一个新的，空的树映射，根据给定的比较器进行排序。

3 TreeMap(Map<? extends K,? extends V> m) 

这个构造函数构造一个新的树映射具有相同映射关系为给定的映射，根据其键的自然顺序进行排序。

4 TreeMap(SortedMap<K,? extends V> m) 

SortedMap中的元素师有序的，这个构造函数构造一个新的树映射具有相同映射关系，并使用相同的顺序在指定的有序映射。

存储结构

TreeMap的排序是基于对key的排序实现的，它的每一个Node代表红黑树的一个节点，Node的数据结构如下：

 static class Node<K, V> implements Map.Entry<K, V> {        //父节点        Node<K, V> parent;        //左节点        Node<K, V> left;        //右节点        Node<K, V> right;        //键        final K key;        //值        V value;        //高度        int height;        Node(Node<K, V> parent, K key) {            this.parent = parent;            this.key = key;            this.height = 1;        }        Node<K, V> copy(Node<K, V> parent) {            Node<K, V> result = new Node<K, V>(parent, key);            if (left != null) {                result.left = left.copy(result);            }            if (right != null) {                result.right = right.copy(result);            }            result.value = value;            result.height = height;            return result;        }

插入删除：
使用一组状态，把查找，创建，等操作进行封装，当root==null时，并且状态为CREATE，则创建一个新Node

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

    V putInternal(K key, V value) {        //查找该节点，并且创建一个新节点        Node<K, V> created = find(key, Relation.CREATE);        V result = created.value;        created.value = value;        return result;    }

    Node<K, V> 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<K, V>(null, key);                size = 1;                modCount++;                return root;            } else {                return null;            }        }        @SuppressWarnings("unchecked")         Comparable<Object> comparableKey = (comparator == NATURAL_ORDER)                ? (Comparable<Object>) key                : null;        Node<K, V> nearest = root;        while (true) {           //传入比较器则用传入的比较，否则用系统的compareTo比较，得到一个comparison值，用来觉得node在树中的位置            int comparison = (comparableKey != null)                    ? comparableKey.compareTo(nearest.key)                    : comparator.compare(key, nearest.key);            if (comparison == 0) {                switch (relation) {                    case LOWER:                    //lower返回小于等于key，且最接近key得节点                    //比如 1，2，3，5 key=4，没有找到4，返回最接近的一个值且小于等于4，所以返回key=3的值                        return nearest.prev();                    case FLOOR:                    case EQUAL:                    case CREATE:                    case CEILING:                    //返回key=该值得node                        return nearest;                    case HIGHER:                    //higher返回大于等于key，且最接近key得节点                        return nearest.next();                }            }    //comparsion<0则为左节点，comparsion>0则为右节点            Node<K, V> child = (comparison < 0) ? nearest.left : nearest.right;            if (child != null) {                nearest = child;                continue;            }            /*             * We found a nearest node. Every key not in the tree has up to two             * nearest nodes, one lower and one higher.             */            if (comparison < 0) { // nearest.key is higher                switch (relation) {                    case LOWER:                    case FLOOR:                        return nearest.prev();                    case CEILING:                    case HIGHER:                        return nearest;                    case EQUAL:                        return null;                    case CREATE:                    //创建一个新节点，指向nearest的左节点                        Node<K, V> created = new Node<K, V>(nearest, key);                        nearest.left = created;                        size++;                        modCount++;                        //调整二叉树保持红黑树特性                        rebalance(nearest, true);                        return created;                }            } else { // comparison > 0, nearest.key is lower                switch (relation) {                    case LOWER:                    case FLOOR:                        return nearest;                    case CEILING:                    case HIGHER:                        return nearest.next();                    case EQUAL:                        return null;                    case CREATE:                      //创建一个新节点，指向nearest的右节点                        Node<K, V> created = new Node<K, V>(nearest, key);                        nearest.right = created;                        size++;                        modCount++;                         //调整二叉树保持红黑树特性                        rebalance(nearest, true);                        return created;                }            }        }    }

插入操作都是同个find方法完成，通过上面分析，基本上清楚了是怎么插入元素的，剩下rebalance方法这里不分析，是红黑树旋转问题，主要是调整二叉树保持平衡。

  public void remove() {            if (last == null) {                throw new IllegalStateException();            }            //删除一个节点            removeInternal(last);            expectedModCount = modCount;            last = null;        }

 void removeInternal(Node<K, V> node) {        //先记录下要删除节点左右节点，及父节点        Node<K, V> left = node.left;        Node<K, V> right = node.right;        Node<K, V> originalParent = node.parent;        if (left != null && right != null) {        //有左右子节点情况        //找出相邻节点，比较左右子树高度，选择高度较高子树        //       1                     1        //     /   \                 /   \        //    *2*   3     ---》     4     3        //   / \   /              /  \   /        //  4   5 6              7    5 6        // /        //7         // 假设选中2节点删除，2的左子树高度比较高，那么2相邻的子节点，adjacent 就为4，反之则为5             Node<K, V> adjacent = (left.height > right.height) ? left.last() : right.first();            removeInternal(adjacent); // takes care of rebalance and size--            int leftHeight = 0;            left = node.left;            if (left != null) {            //断开node节点与左子节点连接                leftHeight = left.height;                adjacent.left = left;                left.parent = adjacent;                node.left = null;            }            int rightHeight = 0;            right = node.right;            if (right != null) {             //断开node节点与右子节点连接                rightHeight = right.height;                adjacent.right = right;                right.parent = adjacent;                node.right = null;            }            adjacent.height = Math.max(leftHeight, rightHeight) + 1;            //断开node节点与父节点连接，并且让相邻节点adjacent，连接上node节点的父节点            replaceInParent(node, adjacent);            return;        } else if (left != null) {         //该节点只有左子节点，把子节点置空            replaceInParent(node, left);            node.left = null;        } else if (right != null) {            //该节点只有右子节点，把子节点置空            replaceInParent(node, right);            node.right = null;        } else {            replaceInParent(node, null);        }        rebalance(originalParent, false);        size--;        modCount++;    }

删除方法比较绕，阅读的时候最好是画图理解，remove中剩下replaceInParent方法，接下来就看下它做了什么：

    private void replaceInParent(Node<K, V> node, Node<K, V> replacement) {        //先把node父节点保存到临时变量，然后断开与父节点的连接        Node<K, V> parent = node.parent;        node.parent = null;        //如果相邻节点不为null，那么相邻节点父节点指向原node节点的父节点        if (replacement != null) {            replacement.parent = parent;        }        //node父节点不为null，那么node不是root节点        if (parent != null) {            //node节点是左节点，那么相邻节点就替换node父节点的左子节点            if (parent.left == node) {                parent.left = replacement;            } else {            //相邻节点就替换node父节点的右子节点                // assert (parent.right == node);                parent.right = replacement;            }        } else {            //node为root节点，故相邻节点直接替换root            root = replacement;        }    }

删除操作分析完了，其他操作就不再分析，这里总结几点：

1、TreeMap的查询、插入、删除效率均没有HashMap高，每次插入删除，如果破坏了红黑树平衡，需要对树旋转操作，一般只有要对key排序时才使用TreeMap。2、TreeMap的key不能为null，而HashMap的key可以为null。3、TreeMap是根据key进行排序的，排序和定位需要依赖比较器或覆写Comparable接口，因此不需要key覆写hashCode方法和equals方法，就可以排除掉重复的key，而HashMap的key则需要通过覆写hashCode方法和equals方法来确保没有重复的key。