Android TreeMap简要源码分析(先不涉及红黑树部分)

仅对源码put 和 remove部分进行简要分析  对红黑树的rebalance操作  暂且不做探究(其实是我还没完全搞明白-.-)

Treemap是类似于HashMap 存放键值对的数据结构  只不过 它是有序的  检索效率比较高的一种数据结构  它实现和继承了一下类和接口 

public class TreeMap<K, V> extends AbstractMap<K, V> implements SortedMap<K, V>, NavigableMap<K, V>, Cloneable, Serializable

AbstractMap 提供了基本的键值操作  SortedMap提供排序功能  NavigableMap 意味着它支持一系列的导航方法，具备针对给定搜索目标返回最接近匹配项的导航方法(此句非原创)

了解了TreeMap的基本信息  下面我们来了解一下它的主要作用  也就是 插入(put)  删除(remove)  以及查找(get) 方法 

其实这三个方法都调用了一个重要的方法  也就是find方法 不同的操作传入的find方法的第二个参数不同  因为  不论是插入 删除 还是查找 都需要先找到相应的key对应的对象  不论是否存在  

 @Override public V get(Object key) {
        Entry<K, V> entry = findByObject(key);  //findByObject调用的  find 方法 find((K) key, EQUAL);
        return entry != null ? entry.getValue() : null;
    }

@Override 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;
    }

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

 Node<K, V> removeInternalByKey(Object key) {
        Node<K, V> node = findByObject(key);
        if (node != null) {
            removeInternal(node);
        }
        return node;
    }

所以 我门的重点是分析find方法  

Node<K, V> find(K key, Relation relation) {
        if (root == null) {   //先判断treemap是不是空。。 是空的话  判断要进行的操作  如果是创建 那么就创建根节点 如果 不是 直接返回空
            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;
            }
        }

        /*
         * 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<Object> comparableKey = (comparator == NATURAL_ORDER)
                ? (Comparable<Object>) key
                : null;

        Node<K, V> nearest = root;  //如果treemap不空 那么 先将根节点赋值给 nearest节点 
        while (true) { //这个循环的作用是寻找需要寻找的节点 找到后返回  
            int comparison = (comparableKey != null)    //首先判断当前比较的节点与要查找的Key的大小比较  因为是排序树  所以要根据比较结果继续查找
                    ? comparableKey.compareTo(nearest.key)
                    : comparator.compare(key, nearest.key);

            /*
             * We found the requested key.
             */
            if (comparison == 0) {  //如果相等  说明 正好找到了  
                switch (relation) {
                    case LOWER:  //要查找比传入的key值小的    就返回找到的上一个即可 
                        return nearest.prev();
                    case FLOOR:   // 下限
                    case EQUAL:    //相等 
                    case CREATE:   //创建
                    case CEILING:   //上限
                        return nearest;
                    case HIGHER:  //比传入值大的
                        return nearest.next();
                }
            }

            Node<K, V> child = (comparison < 0) ? nearest.left : nearest.right; //走到这说明 不相等   如果 key比当前节点小  查找左子树  大 查找右子树 
            if (child != null) {  //如果上一步得到的树不是空  说明还没找到  查找完毕的标准是 要么相等  要么最后节点是空  没找到 
                nearest = child;  //更新  nearest 节点 
                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  // 进行到这了 说明 并没有找到  并且已经找到了key值 的节点所应该存在的位置  
                switch (relation) {  //根据要进行的操作类型 操作即可  
                    case LOWER:
                    case FLOOR:
                        return nearest.prev();  
                    case CEILING:
                    case HIGHER:
                        return nearest;
                    case EQUAL:
                        return null;
                    case CREATE:   //这个是关键  如果是创建操作 也就是put插入操作  那么就创建一个节点  然后修改一些基本属性 最后调节树的平衡即可
                        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:
                        Node<K, V> created = new Node<K, V>(nearest, key);
                        nearest.right = created;
                        size++;
                        modCount++;
                        rebalance(nearest, true);
                        return created;
                }
            }
        }
    }

经过以上 分析  大体了解了  这个过程   主要是 find函数 通过传入 key值  和一个操作值 来进行相应的操作  返回查找到的节点位置 如果是create 那么就直接插入其中  

至此 告一段落  等有时间红黑树完全掌握了 再来扩充