Commons Collections学习笔记（二）

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicabstractclassAbstractBagDecoratorextendsAbstractCollectionDecoratorimplementsBag{
protectedAbstractBagDecorator(){
super();
}
protectedAbstractBagDecorator(Bagbag){
super(bag);
}
protectedBaggetBag(){
return(Bag)getCollection();
}
publicintgetCount(Objectobject){
returngetBag().getCount(object);
}
publicbooleanadd(Objectobject,intcount){
returngetBag().add(object,count);
}
publicbooleanremove(Objectobject,intcount){
returngetBag().remove(object,count);
}
publicSetuniqueSet(){
returngetBag().uniqueSet();
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicabstractclassAbstractSortedBagDecoratorextendsAbstractBagDecoratorimplementsSortedBag
{
protectedAbstractSortedBagDecorator(){
super();
}
protectedAbstractSortedBagDecorator(SortedBagbag){
super(bag);
}
protectedSortedBaggetSortedBag(){
return(SortedBag)getCollection();
}
publicObjectfirst(){
returngetSortedBag().first();
}
publicObjectlast(){
returngetSortedBag().last();
}
publicComparatorcomparator(){
returngetSortedBag().comparator();
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicabstractclassAbstractMapBagimplementsBag
{

/**Themaptousetostorethedata*/
privatetransientMapmap;
/**Thecurrenttotalsizeofthebag*/
privateintsize;
/**Themodificationcountforfailfastiterators*/
privatetransientintmodCount;
/**Themodificationcountforfailfastiterators*/
privatetransientSetuniqueSet;

protectedAbstractMapBag(){
super();
}
protectedAbstractMapBag(Mapmap){
super();
this.map=map;
}
protectedMapgetMap(){
returnmap;
}
publicintsize(){
returnsize;
}
publicbooleanisEmpty(){
returnmap.isEmpty();
}
publicintgetCount(Objectobject){
MutableIntegercount=(MutableInteger)map.get(object);
if(count!=null){
returncount.value;
}
return0;
}
publicbooleancontains(Objectobject){
returnmap.containsKey(object);
}
publicbooleancontainsAll(Collectioncoll){
if(collinstanceofBag){
returncontainsAll((Bag)coll);
}
returncontainsAll(newHashBag(coll));
}
booleancontainsAll(Bagother){
booleanresult=true;
Iteratorit=other.uniqueSet().iterator();
while(it.hasNext()){
Objectcurrent=it.next();
booleancontains=getCount(current)>=other.getCount(current);
result=result&&contains;
}
returnresult;
}
publicIteratoriterator(){
returnnewBagIterator(this);
}
staticclassBagIteratorimplementsIterator
{
privateAbstractMapBagparent;
privateIteratorentryIterator;
privateMap.Entrycurrent;
privateintitemCount;
privatefinalintmods;
privatebooleancanRemove;
publicBagIterator(AbstractMapBagparent){
this.parent=parent;
this.entryIterator=parent.map.entrySet().iterator();
this.current=null;
this.mods=parent.modCount;
this.canRemove=false;
}
publicbooleanhasNext(){
return(itemCount>0||entryIterator.hasNext());
}
publicObjectnext(){
if(parent.modCount!=mods){
thrownewConcurrentModificationException();
}
if(itemCount==0){
current=(Map.Entry)entryIterator.next();
itemCount=((MutableInteger)current.getValue()).value;
}
canRemove=true;
itemCount--;
returncurrent.getKey();
}
publicvoidremove(){
if(parent.modCount!=mods){
thrownewConcurrentModificationException();
}
if(canRemove==false){
thrownewIllegalStateException();
}
MutableIntegermut=(MutableInteger)current.getValue();
if(mut.value>1){
mut.value--;
}else{
entryIterator.remove();
}
parent.size--;
canRemove=false;
}
}
publicbooleanadd(Objectobject){
returnadd(object,1);
}
publicbooleanadd(Objectobject,intnCopies){
modCount++;
if(nCopies>0){
MutableIntegermut=(MutableInteger)map.get(object);
size+=nCopies;
if(mut==null){
map.put(object,newMutableInteger(nCopies));
returntrue;
}else{
mut.value+=nCopies;
returnfalse;
}
}else{
returnfalse;
}
}
publicbooleanaddAll(Collectioncoll){
booleanchanged=false;
Iteratori=coll.iterator();
while(i.hasNext()){
booleanadded=add(i.next());
changed=changed||added;
}
returnchanged;
}
publicvoidclear(){
modCount++;
map.clear();
size=0;
}
publicbooleanremove(Objectobject){
MutableIntegermut=(MutableInteger)map.get(object);
if(mut==null){
returnfalse;
}
modCount++;
map.remove(object);
size-=mut.value;
returntrue;
}
publicbooleanremove(Objectobject,intnCopies){
MutableIntegermut=(MutableInteger)map.get(object);
if(mut==null){
returnfalse;
}
if(nCopies<=0){
returnfalse;
}
modCount++;
if(nCopies<mut.value){
mut.value-=nCopies;
size-=nCopies;
}else{
map.remove(object);
size-=mut.value;
}
returntrue;
}
publicbooleanremoveAll(Collectioncoll){
booleanresult=false;
if(coll!=null){
Iteratori=coll.iterator();
while(i.hasNext()){
booleanchanged=remove(i.next(),1);
result=result||changed;
}
}
returnresult;
}
publicbooleanretainAll(Collectioncoll){
if(collinstanceofBag){
returnretainAll((Bag)coll);
}
returnretainAll(newHashBag(coll));
}
booleanretainAll(Bagother){
booleanresult=false;
Bagexcess=newHashBag();
Iteratori=uniqueSet().iterator();
while(i.hasNext()){
Objectcurrent=i.next();
intmyCount=getCount(current);
intotherCount=other.getCount(current);
if(1<=otherCount&&otherCount<=myCount){
excess.add(current,myCount-otherCount);
}else{
excess.add(current,myCount);
}
}
if(!excess.isEmpty()){
result=removeAll(excess);
}
returnresult;
}
protectedstaticclassMutableInteger
{
/**Thevalueofthismutable.*/
protectedintvalue;
MutableInteger(intvalue){
this.value=value;
}
publicbooleanequals(Objectobj){
if(objinstanceofMutableInteger==false){
returnfalse;
}
return((MutableInteger)obj).value==value;
}
publicinthashCode(){
returnvalue;
}
}

publicObject[]toArray(){
Object[]result=newObject[size()];
inti=0;
Iteratorit=map.keySet().iterator();
while(it.hasNext()){
Objectcurrent=it.next();
for(intindex=getCount(current);index>0;index--){
result[i++]=current;
}
}
returnresult;
}
publicObject[]toArray(Object[]array){
intsize=size();
if(array.length<size){
array=(Object[])Array.newInstance(array.getClass().getComponentType(),size);
}
inti=0;
Iteratorit=map.keySet().iterator();
while(it.hasNext()){
Objectcurrent=it.next();
for(intindex=getCount(current);index>0;index--){
array[i++]=current;
}
}
if(array.length>size){
array[size]=null;//截断多余的空位
}
returnarray;
}
publicSetuniqueSet(){
if(uniqueSet==null){
uniqueSet=UnmodifiableSet.decorate(map.keySet());
}
returnuniqueSet;
}
protectedvoiddoWriteObject(ObjectOutputStreamout)throwsIOException{
out.writeInt(map.size());
for(Iteratorit=map.entrySet().iterator();it.hasNext();){
Map.Entryentry=(Map.Entry)it.next();
out.writeObject(entry.getKey());
out.writeInt(((MutableInteger)entry.getValue()).value);
}
}
protectedvoiddoReadObject(Mapmap,ObjectInputStreamin)throwsIOException,ClassNotFoundException{
this.map=map;
intentrySize=in.readInt();
for(inti=0;i<entrySize;i++){
Objectobj=in.readObject();
intcount=in.readInt();
map.put(obj,newMutableInteger(count));
size+=count;
}
}
publicbooleanequals(Objectobject){
if(object==this){
returntrue;
}
if(objectinstanceofBag==false){
returnfalse;
}
Bagother=(Bag)object;
if(other.size()!=size()){
returnfalse;
}
for(Iteratorit=map.keySet().iterator();it.hasNext();){
Objectelement=it.next();
if(other.getCount(element)!=getCount(element)){
returnfalse;
}
}
returntrue;
}
publicinthashCode(){
inttotal=0;
for(Iteratorit=map.entrySet().iterator();it.hasNext();){
Map.Entryentry=(Map.Entry)it.next();
Objectelement=entry.getKey();
MutableIntegercount=(MutableInteger)entry.getValue();
total+=(element==null?0:element.hashCode())^count.value;
}
returntotal;
}
publicStringtoString(){
if(size()==0){
return"[]";
}
StringBufferbuf=newStringBuffer();
buf.append('[');
Iteratorit=uniqueSet().iterator();
while(it.hasNext()){
Objectcurrent=it.next();
intcount=getCount(current);
buf.append(count);
buf.append(':');
buf.append(current);
if(it.hasNext()){
buf.append(',');
}
}
buf.append(']');
returnbuf.toString();
}

}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicclassHashBagextendsAbstractMapBagimplementsBag,Serializable
{
privatestaticfinallongserialVersionUID=-6561115435802554013L;
publicHashBag(){
super(newHashMap());
}
publicHashBag(Collectioncoll){
this();
addAll(coll);
}
privatevoidwriteObject(ObjectOutputStreamout)throwsIOException{
out.defaultWriteObject();
super.doWriteObject(out);
}
privatevoidreadObject(ObjectInputStreamin)throwsIOException,ClassNotFoundException{
in.defaultReadObject();
super.doReadObject(newHashMap(),in);
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicclassTreeBagextendsAbstractMapBagimplementsSortedBag,Serializable
{
privatestaticfinallongserialVersionUID=-7740146511091606676L;
publicTreeBag(){
super(newTreeMap());
}
publicTreeBag(Comparatorcomparator){
super(newTreeMap(comparator));
}
publicTreeBag(Collectioncoll){
this();
addAll(coll);
}
publicObjectfirst(){
return((SortedMap)getMap()).firstKey();
}
publicObjectlast(){
return((SortedMap)getMap()).lastKey();
}
publicComparatorcomparator(){
return((SortedMap)getMap()).comparator();
}
privatevoidwriteObject(ObjectOutputStreamout)throwsIOException{
out.defaultWriteObject();
out.writeObject(comparator());
super.doWriteObject(out);
}
privatevoidreadObject(ObjectInputStreamin)throwsIOException,ClassNotFoundException{
in.defaultReadObject();
Comparatorcomp=(Comparator)in.readObject();
super.doReadObject(newTreeMap(comp),in);
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicclassPredicatedBagextendsPredicatedCollectionimplementsBag
{
privatestaticfinallongserialVersionUID=-2575833140344736876L;
publicstaticBagdecorate(Bagbag,Predicatepredicate){
returnnewPredicatedBag(bag,predicate);
}
protectedPredicatedBag(Bagbag,Predicatepredicate){
super(bag,predicate);
}
protectedBaggetBag(){
return(Bag)getCollection();
}
publicbooleanadd(Objectobject,intcount){
validate(object);
returngetBag().add(object,count);
}
publicbooleanremove(Objectobject,intcount){
returngetBag().remove(object,count);
}
publicSetuniqueSet(){
returngetBag().uniqueSet();
}
publicintgetCount(Objectobject){
returngetBag().getCount(object);
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->publicclassPredicatedSortedBagextendsPredicatedBagimplementsSortedBag
{
privatestaticfinallongserialVersionUID=3448581314086406616L;
publicstaticSortedBagdecorate(SortedBagbag,Predicatepredicate){
returnnewPredicatedSortedBag(bag,predicate);
}
protectedPredicatedSortedBag(SortedBagbag,Predicatepredicate){
super(bag,predicate);
}
protectedSortedBaggetSortedBag(){
return(SortedBag)getCollection();
}
publicObjectfirst(){
returngetSortedBag().first();
}
publicObjectlast(){
returngetSortedBag().last();
}

publicComparatorcomparator(){
returngetSortedBag().comparator();
}
}

<!--<br /><br />Code highlighting produced by Actipro CodeHighlighter (freeware)<br />http://www.CodeHighlighter.com/<br /><br />-->
publicclassTypedBag
{
publicstaticBagdecorate(Bagbag,Classtype){
returnnewPredicatedBag(bag,InstanceofPredicate.getInstance(type));
}
protectedTypedBag(){
super();
}
}
publicclassTypedSortedBag
{
publicstaticSortedBagdecorate(SortedBagbag,Classtype){
returnnewPredicatedSortedBag(bag,InstanceofPredicate.getInstance(type));
}
protectedTypedSortedBag()
{
super();
}
}