Commons Collections学习笔记（三）

这个Map类是基于红黑树构建的，每个树节点有两个域，一个存放节点的Key,一个存放节点的Value,相当于是两棵红黑树，一棵是关于key的红黑树，一棵是关于Value的红黑树。

      关于红黑树的详细介绍，参考《C#与数据结构--树论--红黑树（Red Black Tree）》这篇文章。

public   final   class  DoubleOrderedMap  extends  AbstractMap 
{    
private  Node[] rootNode  =   new  Node[] {  null ,  null  }; // 根节点

public  Set entrySetByValue()
 { // 按Value获取Entry集合
         if  (setOfEntries[VALUE]  ==   null ) {
            setOfEntries[VALUE]  =   new  AbstractSet() {
                 public  Iterator iterator() {
                     return   new  DoubleOrderedMapIterator(VALUE) {
                         protected  Object doGetNext() {
                             return  lastReturnedNode;
                        }
                    };
                }
                 public   boolean  contains(Object o) {
                     if  ( ! (o  instanceof  Map.Entry)) {
                         return   false ;
                    }
                    Map.Entry entry  =  (Map.Entry) o;
                    Object    key    =  entry.getKey();
                    Node      node   =  lookup((Comparable) entry.getValue(),
                                             VALUE);
                     return  (node  !=   null )  &&  node.getData(KEY).equals(key);
                }
                 public   boolean  remove(Object o) {
                     if  ( ! (o  instanceof  Map.Entry)) {
                         return   false ;
                    }
                    Map.Entry entry  =  (Map.Entry) o;
                    Object    key    =  entry.getKey();
                    Node      node   =  lookup((Comparable) entry.getValue(),
                                             VALUE);
                     if  ((node  !=   null )  &&  node.getData(KEY).equals(key)) {
                        doRedBlackDelete(node);
                         return   true ;
                    }
                     return   false ;
                }
                 public   int  size() {
                     return  DoubleOrderedMap. this .size();
                }
                 public   void  clear() {
                    DoubleOrderedMap. this .clear();
                }
            };
        }
         return  setOfEntries[VALUE];
}

private  Object doRemove( final  Comparable o,  final   int  index) 
{
        Node   node  =  lookup(o, index); // 在红黑树中查找节点
        Object rval  =   null ;
         if  (node  !=   null )
{
            rval  =  node.getData(oppositeIndex(index));
            doRedBlackDelete(node); // 在红黑树中删除指定节点
        }
         return  rval;
    }
private  Object doGet( final  Comparable o,  final   int  index) 
{
        checkNonNullComparable(o, index); // 检查参数非空
        Node node  =  lookup(o, index); // 按Key或Value查找指定节点
         return  ((node  ==   null ) ?   null : node.getData(oppositeIndex(index)));
    }
private  Node lookup( final  Comparable data,  final   int  index) 
{
        Node rval  =   null ;
        Node node  =  rootNode[index]; // 根节点
         while  (node  !=   null ) 
{
             int  cmp  =  compare(data, node.getData(index)); // 与当前节点比较
             if  (cmp  ==   0 ) 
{ // 找到了
                rval  =  node;
                 break ;
            }  else  { // 在左子树或右子树中寻找
                node  =  (cmp  <   0 )
                        ?  node.getLeft(index)
                       : node.getRight(index);
            }
        }
         return  rval;
    }
private   static  Node leastNode( final  Node node,  final   int  index) 
{ // 返回指定节点的最右子节点
        Node rval  =  node;
         if  (rval  !=   null ) {
             while  (rval.getLeft(index)  !=   null ) {
                rval  =  rval.getLeft(index);
            }
        }
         return  rval;
    }

private  Node nextGreater( final  Node node,  final   int  index)
 { // 返回下一个大于指定节点的节点
        Node rval  =   null ;
         if  (node  ==   null ) {
            rval  =   null ;
        }  else   if  (node.getRight(index)  !=   null ) 
{ // 右子树不为空，返回右子树最左子节点
            rval  =  leastNode(node.getRight(index), index);
        }
else  
{ // 不断向上，只要仍然是右子节点
            Node parent  =  node.getParent(index);
            Node child   =  node;
             while  ((parent  !=   null )  &&  (child  ==  parent.getRight(index))) {
                child   =  parent;
                parent  =  parent.getParent(index);
            }
            rval  =  parent;
        }
         return  rval;
    }

private   void  rotateLeft( final  Node node,  final   int  index) 
{ // 左旋操作
        Node rightChild  =  node.getRight(index);
        node.setRight(rightChild.getLeft(index), index);
         if  (rightChild.getLeft(index)  !=   null ) {
            rightChild.getLeft(index).setParent(node, index);
        }
        rightChild.setParent(node.getParent(index), index);
         if  (node.getParent(index)  ==   null ) 
{ // 设置为根节点
            rootNode[index]  =  rightChild;
        }  else   if  (node.getParent(index).getLeft(index)  ==  node) {
            node.getParent(index).setLeft(rightChild, index);
        }  else  {
            node.getParent(index).setRight(rightChild, index);
        }
        rightChild.setLeft(node, index);
        node.setParent(rightChild, index);
    }

private   void  rotateRight( final  Node node,  final   int  index) 
{ // 右旋操作
        Node leftChild  =  node.getLeft(index);
        node.setLeft(leftChild.getRight(index), index);
         if  (leftChild.getRight(index)  !=   null ) {
            leftChild.getRight(index).setParent(node, index);
        }
        leftChild.setParent(node.getParent(index), index);
         if  (node.getParent(index)  ==   null ) 
{ // 设置为根节点
            rootNode[index]  =  leftChild;
        }  else   if  (node.getParent(index).getRight(index)  ==  node) {
            node.getParent(index).setRight(leftChild, index);
        }  else  {
            node.getParent(index).setLeft(leftChild, index);
        }
        leftChild.setRight(node, index);
        node.setParent(leftChild, index);
}
private   void  doRedBlackInsert( final  Node insertedNode,  final   int  index) 
  { // 进行红黑树节点插入后的调整
        Node currentNode  =  insertedNode; // 新插入节点置为当前节点
        makeRed(currentNode, index); // 标记新节点为红色
         while  ((currentNode  !=   null )  &&  (currentNode  !=  rootNode[index]) &&  (isRed(currentNode.getParent(index), index))) 
        { // 确保当前节点父节点为红色才继续处理
             if  (isLeftChild(getParent(currentNode, index), index)) 
            { // 父节点是祖父节点的左孩子
                Node y  =  getRightChild(getGrandParent(currentNode, index),index); // 叔节点是祖父节点的右孩子
                 if  (isRed(y, index))
                { // 红叔(图4)
                    makeBlack(getParent(currentNode, index), index); // 标记父节点为黑色
                    makeBlack(y, index); // 标记叔节点为黑色
                    makeRed(getGrandParent(currentNode, index), index); // 标记祖父节点为红色
                    currentNode  =  getGrandParent(currentNode, index); // 置祖父节点为当前节点
                } 
                 else  
                { // 黑叔(对应图5和图6)
                     if  (isRightChild(currentNode, index)) 
                    { // 当前节点是父节点的右孩子(图6)
                        currentNode  =  getParent(currentNode, index); // 置父节点为当前节点
                        rotateLeft(currentNode, index); // 左旋
                    }
                    makeBlack(getParent(currentNode, index), index); // 当前节点的父节点置为黑色
                    makeRed(getGrandParent(currentNode, index), index); // 祖父节点置为红色
                     if  (getGrandParent(currentNode, index)  !=   null ) 
                    { // 对祖父节点进行右旋
                        rotateRight(getGrandParent(currentNode, index),index);
                    }
                }
            }  else  
            { // 父节点是祖父节点的右孩子
                Node y  =  getLeftChild(getGrandParent(currentNode, index),index); // 叔节点是祖父节点的左孩子
                 if  (isRed(y, index)) 
                { // 红叔(图4)
                    makeBlack(getParent(currentNode, index), index); // 标记父节点为黑色
                    makeBlack(y, index); // 标记叔节点为黑色
                    makeRed(getGrandParent(currentNode, index), index); // 标记祖父节点为红色
                    currentNode  =  getGrandParent(currentNode, index); // 置祖父节点为当前节点
                } 
                 else
                { // 黑叔(对应图7和图8)
                     if  (isLeftChild(currentNode, index)) 
                    { // 当前节点是父节点的左孩子(图8)
                        currentNode  =  getParent(currentNode, index); // 置父节点为当前节点
                        rotateRight(currentNode, index); // 右旋
                    }
                    makeBlack(getParent(currentNode, index), index); // 当前节点的父节点置为黑色
                    makeRed(getGrandParent(currentNode, index), index); // 祖父节点置为红色
                     if  (getGrandParent(currentNode, index)  !=   null ) 
                    { // 对祖父节点进行左旋
                        rotateLeft(getGrandParent(currentNode, index), index);
                    }
                }
            }
        }
        makeBlack(rootNode[index], index); // 标记根节点为黑色
    }

private   void  doRedBlackDelete( final  Node deletedNode) 
{ // 在红黑树中删除指定节点
         for  ( int  index  =  FIRST_INDEX; index  <  NUMBER_OF_INDICES; index ++ ) {
             //  if deleted node has both left and children, swap with
             //  the next greater node
             if  ((deletedNode.getLeft(index)  !=   null )
                     &&  (deletedNode.getRight(index)  !=   null )) {
                swapPosition(nextGreater(deletedNode, index), deletedNode,
                             index);
            }
            Node replacement  =  ((deletedNode.getLeft(index)  !=   null )
                                 ?  deletedNode.getLeft(index)
                                : deletedNode.getRight(index));
             if  (replacement  !=   null ) {
                replacement.setParent(deletedNode.getParent(index), index);

                 if  (deletedNode.getParent(index)  ==   null ) {
                    rootNode[index]  =  replacement;
                }  else   if  (deletedNode
                            ==  deletedNode.getParent(index).getLeft(index)) {
                    deletedNode.getParent(index).setLeft(replacement, index);
                }  else  {
                    deletedNode.getParent(index).setRight(replacement, index);
                }
                deletedNode.setLeft( null , index);
                deletedNode.setRight( null , index);
                deletedNode.setParent( null , index);
                 if  (isBlack(deletedNode, index)) {
                    doRedBlackDeleteFixup(replacement, index);
                }
            }  else  {
                 //  replacement is null
                 if  (deletedNode.getParent(index)  ==   null ) {
                     //  empty tree
                    rootNode[index]  =   null ;
                }  else  {
                     //  deleted node had no children
                     if  (isBlack(deletedNode, index)) {
                        doRedBlackDeleteFixup(deletedNode, index);
                    }
                     if  (deletedNode.getParent(index)  !=   null ) {
                         if  (deletedNode
                                 ==  deletedNode.getParent(index)
                                    .getLeft(index)) {
                            deletedNode.getParent(index).setLeft( null , index);
                        }  else  {
                            deletedNode.getParent(index).setRight( null ,
                                                  index);
                        }
                        deletedNode.setParent( null , index);
                    }
                }
            }
        }
        shrink();
    }

     private   void  doRedBlackDeleteFixup( final  Node replacementNode,
                                        final   int  index) 
{ // 重新局部平衡红黑树
        Node currentNode  =  replacementNode;
         while  ((currentNode  !=  rootNode[index])
                 &&  (isBlack(currentNode, index))) {
             if  (isLeftChild(currentNode, index)) {
                Node siblingNode  =
                    getRightChild(getParent(currentNode, index), index);
                 if  (isRed(siblingNode, index)) {
                    makeBlack(siblingNode, index);
                    makeRed(getParent(currentNode, index), index);
                    rotateLeft(getParent(currentNode, index), index);
                    siblingNode  =  getRightChild(getParent(currentNode, index), index);
                }
                 if  (isBlack(getLeftChild(siblingNode, index), index)
                         &&  isBlack(getRightChild(siblingNode, index),
                                   index)) {
                    makeRed(siblingNode, index);
                    currentNode  =  getParent(currentNode, index);
                }  else  {
                     if  (isBlack(getRightChild(siblingNode, index), index)) {
                        makeBlack(getLeftChild(siblingNode, index), index);
                        makeRed(siblingNode, index);
                        rotateRight(siblingNode, index);
                        siblingNode  =
                            getRightChild(getParent(currentNode, index), index);
                    }
                    copyColor(getParent(currentNode, index), siblingNode,
                              index);
                    makeBlack(getParent(currentNode, index), index);
                    makeBlack(getRightChild(siblingNode, index), index);
                    rotateLeft(getParent(currentNode, index), index);
                    currentNode  =  rootNode[index];
                }
            }  else  {
                Node siblingNode  =  getLeftChild(getParent(currentNode, index), index);
                 if  (isRed(siblingNode, index)) {
                    makeBlack(siblingNode, index);
                    makeRed(getParent(currentNode, index), index);
                    rotateRight(getParent(currentNode, index), index);
                    siblingNode  =  getLeftChild(getParent(currentNode, index), index);
                }
                 if  (isBlack(getRightChild(siblingNode, index), index)
                         &&  isBlack(getLeftChild(siblingNode, index), index)) {
                    makeRed(siblingNode, index);
                    currentNode  =  getParent(currentNode, index);
                }  else  {
                     if  (isBlack(getLeftChild(siblingNode, index), index)) {
                        makeBlack(getRightChild(siblingNode, index), index);
                        makeRed(siblingNode, index);
                        rotateLeft(siblingNode, index);
                        siblingNode  =
                            getLeftChild(getParent(currentNode, index), index);
                    }
                    copyColor(getParent(currentNode, index), siblingNode,
                              index);
                    makeBlack(getParent(currentNode, index), index);
                    makeBlack(getLeftChild(siblingNode, index), index);
                    rotateRight(getParent(currentNode, index), index);
                    currentNode  =  rootNode[index];
                }
            }
        }
        makeBlack(currentNode, index);
    }
private   void  swapPosition( final  Node x,  final  Node y,  final   int  index) 
{ // 交换树中两个节点
         //  Save initial values.
        Node    xFormerParent      =  x.getParent(index);
        Node    xFormerLeftChild   =  x.getLeft(index);
        Node    xFormerRightChild  =  x.getRight(index);
        Node    yFormerParent      =  y.getParent(index);
        Node    yFormerLeftChild   =  y.getLeft(index);
        Node    yFormerRightChild  =  y.getRight(index);
         boolean  xWasLeftChild      =
            (x.getParent(index)  !=   null )
             &&  (x  ==  x.getParent(index).getLeft(index));
         boolean  yWasLeftChild      =
            (y.getParent(index)  !=   null )
             &&  (y  ==  y.getParent(index).getLeft(index));
         //  Swap, handling special cases of one being the other's parent.
         if  (x  ==  yFormerParent) {     //  x was y's parent
            x.setParent(y, index);
             if  (yWasLeftChild) {
                y.setLeft(x, index);
                y.setRight(xFormerRightChild, index);
            }  else  {
                y.setRight(x, index);
                y.setLeft(xFormerLeftChild, index);
            }
        }  else  {
            x.setParent(yFormerParent, index);
             if  (yFormerParent  !=   null ) {
                 if  (yWasLeftChild) {
                    yFormerParent.setLeft(x, index);
                }  else  {
                    yFormerParent.setRight(x, index);
                }
            }
            y.setLeft(xFormerLeftChild, index);
            y.setRight(xFormerRightChild, index);
        }
         if  (y  ==  xFormerParent) {     //  y was x's parent
            y.setParent(x, index);
             if  (xWasLeftChild) {
                x.setLeft(y, index);
                x.setRight(yFormerRightChild, index);
            }  else  {
                x.setRight(y, index);
                x.setLeft(yFormerLeftChild, index);
            }
        }  else  {
            y.setParent(xFormerParent, index);
             if  (xFormerParent  !=   null ) {
                 if  (xWasLeftChild) {
                    xFormerParent.setLeft(y, index);
                }  else  {
                    xFormerParent.setRight(y, index);
                }
            }
            x.setLeft(yFormerLeftChild, index);
            x.setRight(yFormerRightChild, index);
        }
         //  Fix children's parent pointers
         if  (x.getLeft(index)  !=   null ) {
            x.getLeft(index).setParent(x, index);
        }
         if  (x.getRight(index)  !=   null ) {
            x.getRight(index).setParent(x, index);
        }
         if  (y.getLeft(index)  !=   null ) {
            y.getLeft(index).setParent(y, index);
        }
         if  (y.getRight(index)  !=   null ) {
            y.getRight(index).setParent(y, index);
        }
        x.swapColors(y, index);
         //  Check if root changed
         if  (rootNode[index]  ==  x) {
            rootNode[index]  =  y;
        }  else   if  (rootNode[index]  ==  y) {
            rootNode[index]  =  x;
        }
    }
     public  Object put( final  Object key,  final  Object value)
             throws  ClassCastException, NullPointerException,
                   IllegalArgumentException {
        checkKeyAndValue(key, value);
        Node node  =  rootNode[KEY];
         if  (node  ==   null ) { // 空树
            Node root  =   new  Node((Comparable) key, (Comparable) value);
            rootNode[KEY]    =  root;
            rootNode[VALUE]  =  root;
            grow();
        }  else  {
             while  ( true ) {
                 int  cmp  =  compare((Comparable) key, node.getData(KEY));
                 if  (cmp  ==   0 ) {
                     throw   new  IllegalArgumentException(
                         " Cannot store a duplicate key (/ ""  + key
                         +   " / " ) in  this  Map " );
                }  else   if  (cmp  <   0 ) {
                     if  (node.getLeft(KEY)  !=   null ) {
                        node  =  node.getLeft(KEY);
                    }  else  {
                        Node newNode  =   new  Node((Comparable) key,
                                                (Comparable) value);
                        insertValue(newNode);
                        node.setLeft(newNode, KEY);
                        newNode.setParent(node, KEY);
                        doRedBlackInsert(newNode, KEY);
                        grow();
                         break ;
                    }
                }  else  {     //  cmp > 0
                     if  (node.getRight(KEY)  !=   null ) {
                        node  =  node.getRight(KEY);
                    }  else  {
                        Node newNode  =   new  Node((Comparable) key,
                                                (Comparable) value);
                        insertValue(newNode);
                        node.setRight(newNode, KEY);
                        newNode.setParent(node, KEY);
                        doRedBlackInsert(newNode, KEY);
                        grow();
                         break ;
                    }
                }
            }
        }
         return   null ;
    }
private   abstract   class  DoubleOrderedMapIterator  implements  Iterator 
{
         private   int     expectedModifications;
         protected  Node lastReturnedNode; // 上次访问的节点
         private  Node   nextNode; // 下一个节点(最左子节点)
         private   int     iteratorType;
        DoubleOrderedMapIterator( final   int  type) 
{
            iteratorType           =  type;
            expectedModifications  =  DoubleOrderedMap. this .modifications;
            lastReturnedNode       =   null ;
            nextNode               =  leastNode(rootNode[iteratorType],
                                              iteratorType);
        }
         protected   abstract  Object doGetNext();
         public   final   boolean  hasNext() {
             return  nextNode  !=   null ;
        }
         public   final  Object next()
                 throws  NoSuchElementException,
                       ConcurrentModificationException {
             if  (nextNode  ==   null ) {
                 throw   new  NoSuchElementException();
            }
             if  (modifications  !=  expectedModifications) {
                 throw   new  ConcurrentModificationException();
            }
            lastReturnedNode  =  nextNode;
            nextNode          =  nextGreater(nextNode, iteratorType);
             return  doGetNext();
        }
         public   final   void  remove()
                 throws  IllegalStateException,
                       ConcurrentModificationException {
             if  (lastReturnedNode  ==   null ) {
                 throw   new  IllegalStateException();
            }
             if  (modifications  !=  expectedModifications) {
                 throw   new  ConcurrentModificationException();
            }
            doRedBlackDelete(lastReturnedNode);
            expectedModifications ++ ;
            lastReturnedNode  =   null ;
        }
    }

   // 内部节点类
private   static   final   class  Node  implements  Map.Entry, KeyValue 
{
         private  Comparable[] data; // 数据域（key和value）
         private  Node[]       leftNode; // 左子节点
         private  Node[]       rightNode; // 右子节点
         private  Node[]       parentNode; // 父节点
         private   boolean []    blackColor; // 颜色(红或黑)
    }
}