Commons Collections学习笔记（一）

public   interface  Bag  extends  Collection 
{
     int  getCount(Object object);
     boolean  add(Object object);
     boolean  add(Object object,  int  nCopies);
     boolean  remove(Object object);
     boolean  remove(Object object,  int  nCopies);
    Set uniqueSet();
     int  size();
     boolean  containsAll(Collection coll);
     boolean  removeAll(Collection coll);
     boolean  retainAll(Collection coll);
    Iterator iterator();
}

 

public   interface  SortedBag  extends  Bag
{
     public  Comparator comparator();
     public  Object first();
     public  Object last();
}

 

public   abstract   class  DefaultMapBag  implements  Bag 
{
     private  Map _map  =   null ; // 底层数据存储区
     private   int  _total  =   0 ;  // 元素总个数
     private   int  _mods  =   0 ; // 修改次数
     public  DefaultMapBag() {
    }
     protected  DefaultMapBag(Map map) {
        setMap(map);
    }
     public   boolean  add(Object object) {
         return  add(object,  1 );
    }
     public   boolean  add(Object object,  int  nCopies) {
        _mods ++ ;
         if  (nCopies  >   0 ) {
             int  count  =  (nCopies  +  getCount(object));
            _map.put(object,  new  Integer(count));
            _total  +=  nCopies;
             return  (count  ==  nCopies);
        }  else  {
             return   false ;
        }
    }
     public   boolean  addAll(Collection coll) {
         boolean  changed  =   false ;
        Iterator i  =  coll.iterator();
         while  (i.hasNext()) {
             boolean  added  =  add(i.next());
            changed  =  changed  ||  added;
        }
         return  changed;
    }
     public   void  clear() {
        _mods ++ ;
        _map.clear();
        _total  =   0 ;
    }
     public   boolean  contains(Object object) {
         return  _map.containsKey(object);
    }
     public   boolean  containsAll(Collection coll) {
         return  containsAll( new  HashBag(coll));
    }
     public   boolean  containsAll(Bag other) {
         boolean  result  =   true ;
        Iterator i  =  other.uniqueSet().iterator();
         while  (i.hasNext()) {
            Object current  =  i.next();
             boolean  contains  =  getCount(current)  >=  other.getCount(current);
            result  =  result  &&  contains;
        }
         return  result;
    }
     public   boolean  equals(Object object) {
         if  (object  ==   this ) {
             return   true ;
        }
         if  (object  instanceof  Bag  ==   false ) {
             return   false ;
        }
        Bag other  =  (Bag) object;
         if  (other.size()  !=  size()) {
             return   false ;
        }
         for  (Iterator it  =  _map.keySet().iterator(); it.hasNext();) {
            Object element  =  it.next();
             if  (other.getCount(element)  !=  getCount(element)) {
                 return   false ;
            }
        }
         return   true ;
    }
     public   int  hashCode() {
         return  _map.hashCode();
    }
     public   boolean  isEmpty() {
         return  _map.isEmpty();
    }
     public  Iterator iterator() {
         return   new  BagIterator( this , extractList().iterator());
    }
     static   class  BagIterator  implements  Iterator {
         private  DefaultMapBag _parent  =   null ;
         private  Iterator _support  =   null ; // 原始迭代器
         private  Object _current  =   null ; // 当前元素
         private   int  _mods  =   0 ;
         public  BagIterator(DefaultMapBag parent, Iterator support) {
            _parent  =  parent;
            _support  =  support;
            _current  =   null ;
            _mods  =  parent.modCount();
        }
         public   boolean  hasNext() {
             return  _support.hasNext();
        }
         public  Object next() {
             if  (_parent.modCount()  !=  _mods) {
                 throw   new  ConcurrentModificationException();
            }
            _current  =  _support.next();
             return  _current;
        }
         public   void  remove() {
             if  (_parent.modCount()  !=  _mods) {
                 throw   new  ConcurrentModificationException();
            }
            _support.remove();
            _parent.remove(_current,  1 );
            _mods ++ ;
        }
    }
     public   boolean  remove(Object object) {
         return  remove(object, getCount(object));
    }
     public   boolean  remove(Object object,  int  nCopies) {
        _mods ++ ;
         boolean  result  =   false ;
         int  count  =  getCount(object);
         if  (nCopies  <=   0 ) {
            result  =   false ;
        }  else   if  (count  >  nCopies) {
            _map.put(object,  new  Integer(count  -  nCopies));
            result  =   true ;
            _total  -=  nCopies;
        }  else  {  //  count > 0 && count <= i  
             //  need to remove all
            result  =  (_map.remove(object)  !=   null );
            _total  -=  count;
        }
         return  result;
    }
     public   boolean  removeAll(Collection coll) {
         boolean  result  =   false ;
         if  (coll  !=   null ) {
            Iterator i  =  coll.iterator();
             while  (i.hasNext()) {
                 boolean  changed  =  remove(i.next(),  1 );
                result  =  result  ||  changed;
            }
        }
         return  result;
    }
     public   boolean  retainAll(Collection coll) {
         return  retainAll( new  HashBag(coll));
    }
     public   boolean  retainAll(Bag other) {
         boolean  result  =   false ;
        Bag excess  =   new  HashBag();
        Iterator i  =  uniqueSet().iterator();
         while  (i.hasNext()) {
            Object current  =  i.next();
             int  myCount  =  getCount(current);
             int  otherCount  =  other.getCount(current);
             if  ( 1   <=  otherCount  &&  otherCount  <=  myCount) {
                excess.add(current, myCount  -  otherCount);
            }  else  {
                excess.add(current, myCount);
            }
        }
         if  ( ! excess.isEmpty()) {
            result  =  removeAll(excess);
        }
         return  result;
    }
     public  Object[] toArray() {
         return  extractList().toArray();
    }
     public  Object[] toArray(Object[] array) {
         return  extractList().toArray(array);
    }
     public   int  getCount(Object object) {
         int  result  =   0 ;
        Integer count  =  MapUtils.getInteger(_map, object);
         if  (count  !=   null ) {
            result  =  count.intValue();
        }
         return  result;
    }
     public  Set uniqueSet() {
         return  UnmodifiableSet.decorate(_map.keySet());
    }
     public   int  size() {
         return  _total;
    }
     protected   int  calcTotalSize() {
        _total  =  extractList().size();
         return  _total;
    }
     protected   void  setMap(Map map) {
         if  (map  ==   null   ||  map.isEmpty()  ==   false ) {
             throw   new  IllegalArgumentException( " The map must be non-null and empty " );
        }
        _map  =  map;
    }
     protected  Map getMap() {
         return  _map;
    }
     private  List extractList() {
        List result  =   new  ArrayList();
        Iterator i  =  uniqueSet().iterator();
         while  (i.hasNext()) {
            Object current  =  i.next();
             for  ( int  index  =  getCount(current); index  >   0 ; index -- ) {
                result.add(current);
            }
        }
         return  result;
    }
     private   int  modCount() {
         return  _mods;
    }
     public  String toString() {
        StringBuffer buf  =   new  StringBuffer();
        buf.append( " [ " );
        Iterator i  =  uniqueSet().iterator();
         while  (i.hasNext()) {
            Object current  =  i.next();
             int  count  =  getCount(current);
            buf.append(count);
            buf.append( " : " );
            buf.append(current);
             if  (i.hasNext()) {
                buf.append( " , " );
            }
        }
        buf.append( " ] " );
         return  buf.toString();
    }
}

 

public   class  HashBag  extends  DefaultMapBag  implements  Bag 
{
     public  HashBag() {
         super ( new  HashMap());
    }
     public  HashBag(Collection coll) {
         this ();
        addAll(coll);
    }
}

 

public   class  TreeBag  extends  DefaultMapBag  implements  SortedBag 
{
     public  TreeBag() {
         super ( new  TreeMap());
    }
     public  TreeBag(Comparator comparator) {
         super ( new  TreeMap(comparator));
    }
     public  TreeBag(Collection coll) {
         this ();
        addAll(coll);
    }
     public  Object first() {
         return  ((SortedMap) getMap()).firstKey();
    }
     public  Object last() {
         return  ((SortedMap) getMap()).lastKey();
    }
     public  Comparator comparator() {
         return  ((SortedMap) getMap()).comparator();
    }
}

使用decorate模式的Bag工具类

public   class  BagUtils 
{
     /**
     * An empty unmodifiable bag.
      */
     public   static   final  Bag EMPTY_BAG  =  UnmodifiableBag.decorate( new  HashBag());

     /**
     * An empty unmodifiable sorted bag.
      */
public   static   final  Bag EMPTY_SORTED_BAG  =  UnmodifiableSortedBag.decorate( new  TreeBag());

     public  BagUtils() { // 这里按常理不应该是public，应该是private才对，作者应该有其他地方要用到吧
    }
     public   static  Bag synchronizedBag(Bag bag) {
         return  SynchronizedBag.decorate(bag);
    }
     public   static  Bag unmodifiableBag(Bag bag) {
         return  UnmodifiableBag.decorate(bag);
    }
     public   static  Bag predicatedBag(Bag bag, Predicate predicate) {
         return  PredicatedBag.decorate(bag, predicate);
    }
     public   static  Bag typedBag(Bag bag, Class type) {
         return  TypedBag.decorate(bag, type);
    }
     public   static  Bag transformedBag(Bag bag, Transformer transformer) {
         return  TransformedBag.decorate(bag, transformer);
    }
     public   static  SortedBag synchronizedSortedBag(SortedBag bag) {
         return  SynchronizedSortedBag.decorate(bag);
    }
     public   static  SortedBag unmodifiableSortedBag(SortedBag bag) {
         return  UnmodifiableSortedBag.decorate(bag);
    }
     public   static  SortedBag predicatedSortedBag(SortedBag bag, Predicate predicate) {
         return  PredicatedSortedBag.decorate(bag, predicate);
    }
     public   static  SortedBag typedSortedBag(SortedBag bag, Class type) {
         return  TypedSortedBag.decorate(bag, type);
    }
     public   static  SortedBag transformedSortedBag(SortedBag bag, Transformer transformer) {
         return  TransformedSortedBag.decorate(bag, transformer);
    }
}