java 集合类源码分析--collections
我認(rèn)為Collections類主要是完成了兩個(gè)主要功能?
1.提供了若干簡(jiǎn)單而又有用的算法，比如排序，二分查找，求最大最小值等等。?
2.提供對(duì)集合進(jìn)行包裝的靜態(tài)方法。比如把指定的集合包裝成線程安全的集合、包裝成不可修改的集合、包裝成類型安全的集合等。?
package?java.util;
import?java.io.Serializable;
import?java.io.ObjectOutputStream;
import?java.io.IOException;
import?java.lang.reflect.Array;
public?class?Collections{
????//?Suppresses?default?constructor,?ensuring?non-instantiability.
????private?Collections()?{
????}
????//?算法
????/*
?????*?
?????*?算法需要用到的一些參數(shù)。所有的關(guān)于List的算法都有兩種實(shí)現(xiàn)，一種是適合隨機(jī)訪問的
?????*?List，另一種是適合連續(xù)訪問的。
?????*/
????private?static?final?int?BINARYSEARCH_THRESHOLD???=?5000;
????private?static?final?int?REVERSE_THRESHOLD????????=???18;
????private?static?final?int?SHUFFLE_THRESHOLD????????=????5;
????private?static?final?int?FILL_THRESHOLD???????????=???25;
????private?static?final?int?ROTATE_THRESHOLD?????????=??100;
????private?static?final?int?COPY_THRESHOLD???????????=???10;
????private?static?final?int?REPLACEALL_THRESHOLD?????=???11;
????private?static?final?int?INDEXOFSUBLIST_THRESHOLD?=???35;
????/**
?????*
?????*?List中的所有元素必須實(shí)現(xiàn)Compareable接口,即每個(gè)?元素必須是可比的。
?????*?
?????*?算法的實(shí)現(xiàn)原理為：
?????*?把指定的List轉(zhuǎn)化為一個(gè)對(duì)象數(shù)組，對(duì)數(shù)組進(jìn)行排序，然后迭代List的每一個(gè)元素，
?????*?在同樣的位置重新設(shè)置數(shù)組中排好序的元素
?????*/
????public?static?<T?extends?Comparable<??super?T>>?void?sort(List<T>?list)?{
Object[]?a?=?list.toArray();?//轉(zhuǎn)化為對(duì)象數(shù)組用的歸并
Arrays.sort(a);?//對(duì)數(shù)組排序，使用了歸并排序.對(duì)此歸并的詳細(xì)分析可見我另一篇博客
ListIterator<T>?i?=?list.listIterator();
for?(int?j=0;?j<a.length;?j++)?{?//迭代元素
???i.next();
???i.set((T)a[j]);?//在同樣的位置重設(shè)排好序的值
}
????}
????
????
????/**
?????*?傳一個(gè)實(shí)現(xiàn)了Comparator接口的對(duì)象進(jìn)來。
?????*?c.compare(o1,o2);來比較兩個(gè)元素
?????*/
????public?static?<T>?void?sort(List<T>?list,?Comparator<??super?T>?c)?{
Object[]?a?=?list.toArray();
Arrays.sort(a,?(Comparator)c);
ListIterator?i?=?list.listIterator();
for?(int?j=0;?j<a.length;?j++)?{
???i.next();
???i.set(a[j]);
}
????}
????/**
?????*
?????*?使用二分查找在指定List中查找指定元素key。
?????*?List中的元素必須是有序的。如果List中有多個(gè)key，不能確保哪個(gè)key值被找到。
?????*?如果List不是有序的，返回的值沒有任何意義
?????*?
?????*?對(duì)于隨機(jī)訪問列表來說，時(shí)間復(fù)雜度為O(log(n)),比如1024個(gè)數(shù)只需要查找log2(1024)=10次，
?????*?log2(n)是最壞的情況，即最壞的情況下都只需要找10次
?????*?對(duì)于鏈表來說，查找中間元素的時(shí)間復(fù)雜度為O(n),元素比較的時(shí)間復(fù)雜度為O(log(n))
?????*?
?????*?@return?查找元素的索引。如果返回的是負(fù)數(shù)表明找不到此元素，但可以用返回值計(jì)算
?????*??應(yīng)該將key插入到集合什么位置，任然能使集合有序(如果需要插入key值的話)。
?????*?公式：point??=?-i?-?1
?????*?
?????*/
????public?static?<T>?int?binarySearch(List<??extends?Comparable<??super?T>>?list,?T?key)?{
????????if?(list?instanceof?RandomAccess?||?list.size()<BINARYSEARCH_THRESHOLD)
????????????return?Collections.indexedBinarySearch(list,?key);
????????else
????????????return?Collections.iteratorBinarySearch(list,?key);
????}
????/**
?????*?使用索引化二分查找。
?????*?size小于5000的鏈表也用此方法查找
?????*/
????private?static?<T>?int?indexedBinarySearch(List<??extends?Comparable<??super?T>>?list,?T?key){
int?low?=?0;??//元素所在范圍的下界
int?high?=?list.size()-1;?//上界
while?(low?<=?high)?{
???int?mid?=?(low?+?high)?>>>?1;
???Comparable<??super?T>?midVal?=?list.get(mid);?//中間值
???int?cmp?=?midVal.compareTo(key);?//指定元素與中間值比較
???if?(cmp?<?0)
????low?=?mid?+?1;?//重新設(shè)置上界和下界
???else?if?(cmp?>?0)
????high?=?mid?-?1;
???else
????return?mid;?//?key?found
}
return?-(low?+?1);??//?key?not?found
????}
????/**
?????*?迭代式二分查找，線性查找，依次查找得中間值
?????*?
?????*/
????private?static?<T>?int?iteratorBinarySearch(List<??extends?Comparable<??super?T>>?list,?T?key){
int?low?=?0;
int?high?=?list.size()-1;
???????ListIterator<??extends?Comparable<??super?T>>?i?=?list.listIterator();
???????while?(low?<=?high)?{
???????????int?mid?=?(low?+?high)?>>>?1;
???????????Comparable<??super?T>?midVal?=?get(i,?mid);
???????????int?cmp?=?midVal.compareTo(key);
???????????if?(cmp?<?0)
???????????????low?=?mid?+?1;
???????????else?if?(cmp?>?0)
???????????????high?=?mid?-?1;
???????????else
???????????????return?mid;?//?key?found
???????}
???????return?-(low?+?1);??//?key?not?found
????}
????private?static?<T>?T?get(ListIterator<??extends?T>?i,?int?index)?{
T?obj?=?null;
????????int?pos?=?i.nextIndex();?//根據(jù)當(dāng)前迭代器的位置確定是向前還是向后遍歷找中間值
????????if?(pos?<=?index)?{
????????????do?{
????????????????obj?=?i.next();
????????????}?while?(pos++?<?index);
????????}?else?{
????????????do?{
????????????????obj?=?i.previous();
????????????}?while?(--pos?>?index);
????????}
????????return?obj;
????}
????/**
?????*?提供實(shí)現(xiàn)了Comparator接口的對(duì)象比較元素
?????*/
????public?static?<T>?int?binarySearch(List<??extends?T>?list,?T?key,?Comparator<??super?T>?c)?{
????????if?(c==null)
????????????return?binarySearch((List)?list,?key);
????????if?(list?instanceof?RandomAccess?||?list.size()<BINARYSEARCH_THRESHOLD)
????????????return?Collections.indexedBinarySearch(list,?key,?c);
????????else
????????????return?Collections.iteratorBinarySearch(list,?key,?c);
????}
????private?static?<T>?int?indexedBinarySearch(List<??extends?T>?l,?T?key,?Comparator<??super?T>?c)?{
int?low?=?0;
int?high?=?l.size()-1;
while?(low?<=?high)?{
???int?mid?=?(low?+?high)?>>>?1;
???T?midVal?=?l.get(mid);
???int?cmp?=?c.compare(midVal,?key);
???if?(cmp?<?0)
low?=?mid?+?1;
???else?if?(cmp?>?0)
high?=?mid?-?1;
???else
return?mid;?//?key?found
}
return?-(low?+?1);??//?key?not?found
????}
????private?static?<T>?int?iteratorBinarySearch(List<??extends?T>?l,?T?key,?Comparator<??super?T>?c)?{
int?low?=?0;
int?high?=?l.size()-1;
???????ListIterator<??extends?T>?i?=?l.listIterator();
???????while?(low?<=?high)?{
???????????int?mid?=?(low?+?high)?>>>?1;
???????????T?midVal?=?get(i,?mid);
???????????int?cmp?=?c.compare(midVal,?key);
???????????if?(cmp?<?0)
???????????????low?=?mid?+?1;
???????????else?if?(cmp?>?0)
???????????????high?=?mid?-?1;
???????????else
???????????????return?mid;?//?key?found
???????}
???????return?-(low?+?1);??//?key?not?found
????}
????private?interface?SelfComparable?extends?Comparable<SelfComparable>?{}
????/**
?????*?
?????*?逆序排列指定列表中的元素
?????*/
????public?static?void?reverse(List<?>?list)?{
????????int?size?=?list.size();
????????//如果是size小于18的鏈表或是基于隨機(jī)訪問的列表
????????if?(size?<?REVERSE_THRESHOLD?||?list?instanceof?RandomAccess)?{
????????????for?(int?i=0,?mid=size>>1,?j=size-1;?i<mid;?i++,?j--)?//第一個(gè)與最后一個(gè)，依次交換
????????????????swap(list,?i,?j);?//交換i和j位置的值
????????}?else?{?//基于迭代器的逆序排列算法
????????????ListIterator?fwd?=?list.listIterator();
????????????ListIterator?rev?=?list.listIterator(size);
????????????for?(int?i=0,?mid=list.size()>>1;?i<mid;?i++)?{?//這..，一個(gè)思想你懂得
????????????Object?tmp?=?fwd.next();
????????????????fwd.set(rev.previous());
????????????????rev.set(tmp);
????????????}
????????}
????}
????/**
?????*?
?????*?對(duì)指定列表中的元素進(jìn)行混排
?????*/
????public?static?void?shuffle(List<?>?list)?{
????????if?(r?==?null)?{
????????????r?=?new?Random();
????????}
????????shuffle(list,?r);
????}
????private?static?Random?r;
????/**
?????*?
?????*?提供一個(gè)隨機(jī)數(shù)生成器對(duì)指定List進(jìn)行混排
?????*?
?????*?基本算法思想為：
?????*?逆向遍歷list，從最后一個(gè)元素到第二個(gè)元素，然后重復(fù)交換當(dāng)前位置
?????*?與隨機(jī)產(chǎn)生的位置的元素值。
?????*
?????*?如果list不是基于隨機(jī)訪問并且其size>5,會(huì)先把List中的復(fù)制到數(shù)組中，
?????*?然后對(duì)數(shù)組進(jìn)行混排，再把數(shù)組中的元素重新填入List中。
?????*?這樣做為了避免迭代器大跨度查找元素影響效率
?????*/
????public?static?void?shuffle(List<?>?list,?Random?rnd)?{
????????int?size?=?list.size();
????????if?(size?<?SHUFFLE_THRESHOLD?||?list?instanceof?RandomAccess)?{
????????????for?(int?i=size;?i>1;?i--)?//從i-1個(gè)位置開始與隨機(jī)位置元素交換值
????????????????swap(list,?i-1,?rnd.nextInt(i));
????????}?else?{
????????????Object?arr[]?=?list.toArray();?//先轉(zhuǎn)化為數(shù)組
????????????//對(duì)數(shù)組進(jìn)行混排
????????????for?(int?i=size;?i>1;?i--)
????????????????swap(arr,?i-1,?rnd.nextInt(i));
????????????//?然后把數(shù)組中的元素重新填入List
????????????ListIterator?it?=?list.listIterator();
????????????for?(int?i=0;?i<arr.length;?i++)?{
????????????????it.next();
????????????????it.set(arr[i]);
????????????}
????????}
????}
????/**
?????*?交換List中兩個(gè)位置的值
?????*/
????public?static?void?swap(List<?>?list,?int?i,?int?j)?{
final?List?l?=?list;
l.set(i,?l.set(j,?l.get(i)));?//互換i和j位置的值
????}
????/**
?????*?交換數(shù)組倆位置的值。好熟悉啊
?????*/
????private?static?void?swap(Object[]?arr,?int?i,?int?j)?{
????????Object?tmp?=?arr[i];
????????arr[i]?=?arr[j];
????????arr[j]?=?tmp;
????}
????/**
?????*?
?????*?用obj替換List中的所有元素
?????*?依次遍歷賦值即可
?????*/
????public?static?<T>?void?fill(List<??super?T>?list,?T?obj)?{
????????int?size?=?list.size();
????????if?(size?<?FILL_THRESHOLD?||?list?instanceof?RandomAccess)?{
????????????for?(int?i=0;?i<size;?i++)
????????????????list.set(i,?obj);
????????}?else?{
????????????ListIterator<??super?T>?itr?=?list.listIterator();
????????????for?(int?i=0;?i<size;?i++)?{
????????????????itr.next();
????????????????itr.set(obj);
????????????}
????????}
????}
????/**
?????*?
?????*?復(fù)制源列表的所有元素到目標(biāo)列表，
?????*?如果src.size?>?dest.size?將拋出一個(gè)異常
?????*?如果src.size?<?dest.size?dest中多出的元素將不受影響
?????*?同樣是依次遍歷賦值
?????*/
????public?static?<T>?void?copy(List<??super?T>?dest,?List<??extends?T>?src)?{
????????int?srcSize?=?src.size();
????????if?(srcSize?>?dest.size())?
????????????throw?new?IndexOutOfBoundsException("Source?does?not?fit?in?dest");
????????if?(srcSize?<?COPY_THRESHOLD?||
????????????(src?instanceof?RandomAccess?&&?dest?instanceof?RandomAccess))?{
????????????for?(int?i=0;?i<srcSize;?i++)
????????????????dest.set(i,?src.get(i));
????????}?else?{?//一個(gè)鏈表一個(gè)線性表也可以用迭代器賦值
????????????ListIterator<??super?T>?di=dest.listIterator();
????????????ListIterator<??extends?T>?si=src.listIterator();
????????????for?(int?i=0;?i<srcSize;?i++)?{
????????????????di.next();
????????????????di.set(si.next());
????????????}
????????}
????}
????/**
?????*?
?????*?返回集合中的最小元素。前提是其中的元素都是可比的，即實(shí)現(xiàn)了Comparable接口
?????*?找出一個(gè)通用的算法其實(shí)不容易，盡管它的思想不難。
?????*?反正要依次遍歷完所有元素，所以直接用了迭代器
?????*/
????public?static?<T?extends?Object?&?Comparable<??super?T>>?T?min(Collection<??extends?T>?coll)?{
Iterator<??extends?T>?i?=?coll.iterator();
T?candidate?=?i.next();
while?(i.hasNext())?{
???T?next?=?i.next();
???if?(next.compareTo(candidate)?<?0)
????candidate?=?next;
}
return?candidate;
????}
????/**
?????*?根據(jù)提供的比較器求最小元素
?????*/
????public?static?<T>?T?min(Collection<??extends?T>?coll,?Comparator<??super?T>?comp)?{
????????if?(comp==null)
????????//返回默認(rèn)比較器，其實(shí)默認(rèn)比較器什么也不做，只是看集合元素是否實(shí)現(xiàn)了Comparable接口，
????????//否則拋出ClassCastException
????????????return?(T)min((Collection<SelfComparable>)?(Collection)?coll);
Iterator<??extends?T>?i?=?coll.iterator();
T?candidate?=?i.next();?//假設(shè)第一個(gè)元素為最小元素
????????while?(i.hasNext())?{
???T?next?=?i.next();
???if?(comp.compare(next,?candidate)?<?0)
????candidate?=?next;
????????}
????????return?candidate;
????}
????/**
?????*?求集合中最大元素
?????*/
????public?static?<T?extends?Object?&?Comparable<??super?T>>?T?max(Collection<??extends?T>?coll)?{
Iterator<??extends?T>?i?=?coll.iterator();
T?candidate?=?i.next();
???while?(i.hasNext())?{
???T?next?=?i.next();
???if?(next.compareTo(candidate)?>?0)
????candidate?=?next;
}
return?candidate;
????}
????/**
?????*?根據(jù)指定比較器求集合中最大元素
?????*/
????public?static?<T>?T?max(Collection<??extends?T>?coll,?Comparator<??super?T>?comp)?{
????????if?(comp==null)?
????????return?(T)max((Collection<SelfComparable>)?(Collection)?coll);
????????Iterator<??extends?T>?i?=?coll.iterator();
????????T?candidate?=?i.next();
????????while?(i.hasNext())?{
????????T?next?=?i.next();
????????if?(comp.compare(next,?candidate)?>?0)
????????candidate?=?next;
????????}
return?candidate;
????}
????/**
?????*?
?????*?旋轉(zhuǎn)移位List中的元素通過指定的distance。每個(gè)元素移動(dòng)后的位置為：
?????*?(i?+?distance)%list.size.此方法不會(huì)改變列表的長(zhǎng)度
?????*?
?????*?比如，類表元素為：?[t,?a,?n,?k,?s?,?w]
?????*?執(zhí)行Collections.rotate(list,?2)或
?????*?Collections.rotate(list,?-4)后,?list中的元素將變?yōu)?/span>
?????*?[s,?w,?t,?a,?n?,?k]。可以這樣理解：正數(shù)表示向后移，負(fù)數(shù)表示向前移
?????*
?????*/
????public?static?void?rotate(List<?>?list,?int?distance)?{
????????if?(list?instanceof?RandomAccess?||?list.size()?<?ROTATE_THRESHOLD)
????????????rotate1((List)list,?distance);
????????else
????????????rotate2((List)list,?distance);
????}
????private?static?<T>?void?rotate1(List<T>?list,?int?distance)?{
????????int?size?=?list.size();
????????if?(size?==?0)
????????????return;
????????distance?=?distance?%?size;?//distance始終處于0到size(不包括)之間
????????if?(distance?<?0)
????????????distance?+=?size;?//還是以向后移來計(jì)算的
????????if?(distance?==?0)
????????????return;
????????for?(int?cycleStart?=?0,?nMoved?=?0;?nMoved?!=?size;?cycleStart++)?{
????????????T?displaced?=?list.get(cycleStart);
????????????int?i?=?cycleStart;
????????????do?{?
????????????????i?+=?distance;?//求新位置
????????????????if?(i?>=?size)
????????????????????i?-=?size;?//超出size就減去size
????????????????displaced?=?list.set(i,?displaced);?//為新位置賦原來的值
????????????????nMoved?++;?//如果等于size證明全部替換完畢
????????????}?while(i?!=?cycleStart);?//依次類推，求新位置的新位置
????????}
????}
????private?static?void?rotate2(List<?>?list,?int?distance)?{
????????int?size?=?list.size();
????????if?(size?==?0)
????????????return;
????????int?mid?=??-distance?%?size;
????????if?(mid?<?0)
????????????mid?+=?size;
????????if?(mid?==?0)
????????????return;
????????//好神奇啊
????????reverse(list.subList(0,?mid));
????????reverse(list.subList(mid,?size));
????????reverse(list);
????}
????/**
?????*?
?????*?把指定集合中所有與oladVal相等的元素替換成newVal
?????*?只要list發(fā)生了改變就返回true
?????*/
????public?static?<T>?boolean?replaceAll(List<T>?list,?T?oldVal,?T?newVal)?{
????????boolean?result?=?false;
????????int?size?=?list.size();
????????if?(size?<?REPLACEALL_THRESHOLD?||?list?instanceof?RandomAccess)?{
????????????if?(oldVal==null)?{
????????????????for?(int?i=0;?i<size;?i++)?{
????????????????????if?(list.get(i)==null)?{
????????????????????????list.set(i,?newVal);
????????????????????????result?=?true;
????????????????????}
????????????????}
????????????}?else?{
????????????????for?(int?i=0;?i<size;?i++)?{
????????????????????if?(oldVal.equals(list.get(i)))?{
????????????????????????list.set(i,?newVal);
????????????????????????result?=?true;
????????????????????}
????????????????}
????????????}
????????}?else?{
????????????ListIterator<T>?itr=list.listIterator();
????????????if?(oldVal==null)?{
????????????????for?(int?i=0;?i<size;?i++)?{
????????????????????if?(itr.next()==null)?{
????????????????????????itr.set(newVal);
????????????????????????result?=?true;
????????????????????}
????????????????}
????????????}?else?{
????????????????for?(int?i=0;?i<size;?i++)?{
????????????????????if?(oldVal.equals(itr.next()))?{
????????????????????????itr.set(newVal);
????????????????????????result?=?true;
????????????????????}
????????????????}
????????????}
????????}
????????return?result;
????}
???????static?class?UnmodifiableSortedSet<E>
????????????????????extends?UnmodifiableSet<E>
????????????????????implements?SortedSet<E>,?Serializable?{
????private?static?final?long?serialVersionUID?=?-4929149591599911165L;
????????private?final?SortedSet<E>?ss;
????????UnmodifiableSortedSet(SortedSet<E>?s)?{super(s);?ss?=?s;}
????????public?Comparator<??super?E>?comparator()?{return?ss.comparator();}
????????public?SortedSet<E>?subSet(E?fromElement,?E?toElement)?{
????????????return?new?UnmodifiableSortedSet<E>(ss.subSet(fromElement,toElement));
????????}
????????public?SortedSet<E>?headSet(E?toElement)?{
????????????return?new?UnmodifiableSortedSet<E>(ss.headSet(toElement));
????????}
????????public?SortedSet<E>?tailSet(E?fromElement)?{
????????????return?new?UnmodifiableSortedSet<E>(ss.tailSet(fromElement));
????????}
????????public?E?first()???????????{return?ss.first();}
????????public?E?last()?????????????{return?ss.last();}
????}
????/**
?????*?返回一個(gè)?不可修改的List
?????*?如果原List實(shí)現(xiàn)了RandomAccess接口，返回的List也將實(shí)現(xiàn)此接口
?????*/
????public?static?<T>?List<T>?unmodifiableList(List<??extends?T>?list)?{
return?(list?instanceof?RandomAccess??
???????????????new?UnmodifiableRandomAccessList<T>(list)?:
???????????????new?UnmodifiableList<T>(list));
????}
???
????????/**
?????????*?
?????????*?需要重新包裝返回的EntrySet對(duì)象
?????????*/
????????static?class?UnmodifiableEntrySet<K,V>?extends?UnmodifiableSet<Map.Entry<K,V>>?{
????????private?static?final?long?serialVersionUID?=?7854390611657943733L;
????????????UnmodifiableEntrySet(Set<??extends?Map.Entry<??extends?K,???extends?V>>?s)?{
????????????????super((Set)s);
????????????}
????????????public?Iterator<Map.Entry<K,V>>?iterator()?{
????????????????return?new?Iterator<Map.Entry<K,V>>()?{
????????????????//父類UnmodifiableColletion的c
????????????????Iterator<??extends?Map.Entry<??extends?K,???extends?V>>?i?=?c.iterator();
????????????????????public?boolean?hasNext()?{
????????????????????????return?i.hasNext();
????????????????????}
????????????????????public?Map.Entry<K,V>?next()?{
????????????????????return?new?UnmodifiableEntry<K,V>(i.next());
????????????????????}
????????????????????public?void?remove()?{
????????????????????????throw?new?UnsupportedOperationException();
????????????????????}
????????????????};
????????????}
????????????public?Object[]?toArray()?{
????????????????Object[]?a?=?c.toArray();
????????????????for?(int?i=0;?i<a.length;?i++)
????????????????????a[i]?=?new?UnmodifiableEntry<K,V>((Map.Entry<K,V>)a[i]);
????????????????return?a;
????????????}
????????????public?<T>?T[]?toArray(T[]?a)?{
???????????????
????????????Object[]?arr?=?c.toArray(a.length==0???a?:?Arrays.copyOf(a,?0));
????????????????for?(int?i=0;?i<arr.length;?i++)
????????????????????arr[i]?=?new?UnmodifiableEntry<K,V>((Map.Entry<K,V>)arr[i]);
????????????????if?(arr.length?>?a.length)
????????????????????return?(T[])arr;
????????????????System.arraycopy(arr,?0,?a,?0,?arr.length);
????????????????if?(a.length?>?arr.length)
????????????????????a[arr.length]?=?null;
????????????????return?a;
????????????}
????????????public?boolean?contains(Object?o)?{
????????????????if?(!(o?instanceof?Map.Entry))
????????????????????return?false;
????????????????return?c.contains(new?UnmodifiableEntry<K,V>((Map.Entry<K,V>)?o));
????????????}
????????????public?boolean?containsAll(Collection<?>?coll)?{
????????????????Iterator<?>?e?=?coll.iterator();
????????????????while?(e.hasNext())
????????????????????if?(!contains(e.next()))?//?Invokes?safe?contains()?above
????????????????????????return?false;
????????????????return?true;
????????????}
????????????public?boolean?equals(Object?o)?{
????????????????if?(o?==?this)
????????????????????return?true;
????????????????if?(!(o?instanceof?Set))
????????????????????return?false;
????????????????Set?s?=?(Set)?o;
????????????????if?(s.size()?!=?c.size())
????????????????????return?false;
????????????????return?containsAll(s);?//?Invokes?safe?containsAll()?above
????????????}
????????????/**
?????????????*?重新包裝Entry。
?????????????*/
????????????private?static?class?UnmodifiableEntry<K,V>?implements?Map.Entry<K,V>?{
????????????????private?Map.Entry<??extends?K,???extends?V>?e;
????????????????UnmodifiableEntry(Map.Entry<??extends?K,???extends?V>?e)?{this.e?=?e;}
????????????????public?K?getKey()??{return?e.getKey();}
????????????????public?V?getValue()??{return?e.getValue();}
????????????????public?V?setValue(V?value)?{??//調(diào)用set方法將拋出一個(gè)異常
????????????????????throw?new?UnsupportedOperationException();
????????????????}
????????????????public?int?hashCode()??{return?e.hashCode();}
????????????????public?boolean?equals(Object?o)?{
????????????????????if?(!(o?instanceof?Map.Entry))
????????????????????????return?false;
????????????????????Map.Entry?t?=?(Map.Entry)o;
????????????????????return?eq(e.getKey(),???t.getKey())?&&
???????????????????????????eq(e.getValue(),?t.getValue());
????????????????}
????????????????public?String?toString()??{return?e.toString();}
????????????}
????????}
????}
????/**
?????*?返回一個(gè)線程安全的Set
?????*/
????public?static?<T>?Set<T>?synchronizedSet(Set<T>?s)?{
????return?new?SynchronizedSet<T>(s);
????}
????static?<T>?Set<T>?synchronizedSet(Set<T>?s,?Object?mutex)?{
????return?new?SynchronizedSet<T>(s,?mutex);
????}
????/**
?????*?@serial?include
?????*/
????static?class?SynchronizedSet<E>?extends?SynchronizedCollection<E>?implements?Set<E>?{
????private?static?final?long?serialVersionUID?=?487447009682186044L;
SynchronizedSet(Set<E>?s)?{
???????????super(s);
???}
SynchronizedSet(Set<E>?s,?Object?mutex)?{
???????????super(s,?mutex);
???}
public?boolean?equals(Object?o)?{
???synchronized(mutex)?{return?c.equals(o);}
???}
public?int?hashCode()?{
???synchronized(mutex)?{return?c.hashCode();}
???}
????}
????/**
?????*?@serial?include
?????*/
????static?class?SynchronizedSortedSet<E>?extends?SynchronizedSet<E>implements?SortedSet<E>{
????private?static?final?long?serialVersionUID?=?8695801310862127406L;
????????final?private?SortedSet<E>?ss;
????????SynchronizedSortedSet(SortedSet<E>?s)?{
????????????super(s);
????????????ss?=?s;
????????}
????????SynchronizedSortedSet(SortedSet<E>?s,?Object?mutex)?{
????????????super(s,?mutex);
????????????ss?=?s;
????????}
????????public?Comparator<??super?E>?comparator()?{
????????synchronized(mutex)?{return?ss.comparator();}
????????}
????????public?SortedSet<E>?subSet(E?fromElement,?E?toElement)?{
???synchronized(mutex)?{
????????????????return?new?SynchronizedSortedSet<E>(
????????????????????ss.subSet(fromElement,?toElement),?mutex);
????????????}
????????}
????????public?SortedSet<E>?headSet(E?toElement)?{
????????synchronized(mutex)?{
????????????????return?new?SynchronizedSortedSet<E>(ss.headSet(toElement),?mutex);
????????????}
????????}
????????public?SortedSet<E>?tailSet(E?fromElement)?{
????????synchronized(mutex)?{
???????????????return?new?SynchronizedSortedSet<E>(ss.tailSet(fromElement),mutex);
????????????}
????????}
????????public?E?first()?{
????????synchronized(mutex)?{return?ss.first();}
????????}
????????public?E?last()?{
????????synchronized(mutex)?{return?ss.last();}
????????}
????}
????/**
?????*?返回一個(gè)線程安全的List，
?????*?如果List是基于隨機(jī)訪問的，返回的List同樣實(shí)現(xiàn)了RandomAccess接口
?????*/
????public?static?<T>?List<T>?synchronizedList(List<T>?list)?{
????return?(list?instanceof?RandomAccess??
????????????????new?SynchronizedRandomAccessList<T>(list)?:
????????????????new?SynchronizedList<T>(list));
????}
????static?<T>?List<T>?synchronizedList(List<T>?list,?Object?mutex)?{
????return?(list?instanceof?RandomAccess??
????????????????new?SynchronizedRandomAccessList<T>(list,?mutex)?:
????????????????new?SynchronizedList<T>(list,?mutex));
????}
????/**
?????*?@serial?include
?????*/
????static?class?SynchronizedList<E>extends?SynchronizedCollection<E>?implements?List<E>?{
????????static?final?long?serialVersionUID?=?-7754090372962971524L;
????????final?List<E>?list;
????????SynchronizedList(List<E>?list)?{
????????super(list);
????????this.list?=?list;
????????}
????????SynchronizedList(List<E>?list,?Object?mutex)?{
????????????super(list,?mutex);
????????????this.list?=?list;
????????}
????????public?boolean?equals(Object?o)?{
????????synchronized(mutex)?{return?list.equals(o);}
????????}
????????public?int?hashCode()?{
????????synchronized(mutex)?{return?list.hashCode();}
????????}
????????public?E?get(int?index)?{
????????synchronized(mutex)?{return?list.get(index);}
????????}
????????public?E?set(int?index,?E?element)?{
????????synchronized(mutex)?{return?list.set(index,?element);}
????????}
????????public?void?add(int?index,?E?element)?{
????????synchronized(mutex)?{list.add(index,?element);}
????????}
????????public?E?remove(int?index)?{
????????synchronized(mutex)?{return?list.remove(index);}
????????}
????????public?int?indexOf(Object?o)?{
????????synchronized(mutex)?{return?list.indexOf(o);}
????????}
????????public?int?lastIndexOf(Object?o)?{
????????synchronized(mutex)?{return?list.lastIndexOf(o);}
????????}
????????public?boolean?addAll(int?index,?Collection<??extends?E>?c)?{
????????synchronized(mutex)?{return?list.addAll(index,?c);}
????????}
????????public?ListIterator<E>?listIterator()?{
????????return?list.listIterator();?//?Must?be?manually?synched?by?user
????????}
????????public?ListIterator<E>?listIterator(int?index)?{
????????return?list.listIterator(index);?//?Must?be?manually?synched?by?user
????????}
????????public?List<E>?subList(int?fromIndex,?int?toIndex)?{
????????synchronized(mutex)?{
????????????????return?new?SynchronizedList<E>(list.subList(fromIndex,?toIndex),
????????????????????????????????????????????mutex);
????????????}
????????}
????????private?Object?readResolve()?{
????????????return?(list?instanceof?RandomAccess
?????new?SynchronizedRandomAccessList<E>(list)
???:?this);
????????}
????}
????/**
?????*?@serial?include
?????*/
????static?class?SynchronizedRandomAccessList<E>extends?SynchronizedList<E>
implements?RandomAccess?{
????????SynchronizedRandomAccessList(List<E>?list)?{
????????????super(list);
????????}
????????SynchronizedRandomAccessList(List<E>?list,?Object?mutex)?{
????????????super(list,?mutex);
????????}
????????public?List<E>?subList(int?fromIndex,?int?toIndex)?{
????????synchronized(mutex)?{
????????????????return?new?SynchronizedRandomAccessList<E>(
????????????????????list.subList(fromIndex,?toIndex),?mutex);
????????????}
????????}
????????static?final?long?serialVersionUID?=?1530674583602358482L;
????????private?Object?writeReplace()?{
????????????return?new?SynchronizedList<E>(list);
????????}
????}
????/**
?????*?返回一個(gè)線程安全的map
?????*/
????public?static?<K,V>?Map<K,V>?synchronizedMap(Map<K,V>?m)?{
return?new?SynchronizedMap<K,V>(m);
????}
????/**
?????*?@serial?include
?????*/
????private?static?class?SynchronizedMap<K,V>
implements?Map<K,V>,?Serializable?{
//?use?serialVersionUID?from?JDK?1.2.2?for?interoperability
private?static?final?long?serialVersionUID?=?1978198479659022715L;
private?final?Map<K,V>?m;?????//?Backing?Map
????????final?Object??????mutex;?//?Object?on?which?to?synchronize
SynchronizedMap(Map<K,V>?m)?{
????????????if?(m==null)
????????????????throw?new?NullPointerException();
????????????this.m?=?m;
????????????mutex?=?this;
????????}
SynchronizedMap(Map<K,V>?m,?Object?mutex)?{
????????????this.m?=?m;
????????????this.mutex?=?mutex;
????????}
public?int?size()?{
???synchronized(mutex)?{return?m.size();}
????????}
public?boolean?isEmpty(){
???synchronized(mutex)?{return?m.isEmpty();}
????????}
public?boolean?containsKey(Object?key)?{
???synchronized(mutex)?{return?m.containsKey(key);}
????????}
public?boolean?containsValue(Object?value){
???synchronized(mutex)?{return?m.containsValue(value);}
????????}
public?V?get(Object?key)?{
???synchronized(mutex)?{return?m.get(key);}
????????}
public?V?put(K?key,?V?value)?{
???synchronized(mutex)?{return?m.put(key,?value);}
????????}
public?V?remove(Object?key)?{
???synchronized(mutex)?{return?m.remove(key);}
????????}
public?void?putAll(Map<??extends?K,???extends?V>?map)?{
???synchronized(mutex)?{m.putAll(map);}
????????}
public?void?clear()?{
???synchronized(mutex)?{m.clear();}
}
private?transient?Set<K>?keySet?=?null;
private?transient?Set<Map.Entry<K,V>>?entrySet?=?null;
private?transient?Collection<V>?values?=?null;
public?Set<K>?keySet()?{
????????????synchronized(mutex)?{
????????????????if?(keySet==null)
????????????????????keySet?=?new?SynchronizedSet<K>(m.keySet(),?mutex);
????????????????return?keySet;
????????????}
}
public?Set<Map.Entry<K,V>>?entrySet()?{
????????????synchronized(mutex)?{
????????????????if?(entrySet==null)
????????????????????entrySet?=?new?SynchronizedSet<Map.Entry<K,V>>(m.entrySet(),?mutex);
????????????????return?entrySet;
????????????}
}
public?Collection<V>?values()?{
????????????synchronized(mutex)?{
????????????????if?(values==null)
????????????????????values?=?new?SynchronizedCollection<V>(m.values(),?mutex);
????????????????return?values;
????????????}
????????}
public?boolean?equals(Object?o)?{
????????????synchronized(mutex)?{return?m.equals(o);}
????????}
public?int?hashCode()?{
????????????synchronized(mutex)?{return?m.hashCode();}
????????}
public?String?toString()?{
???synchronized(mutex)?{return?m.toString();}
????????}
????????private?void?writeObject(ObjectOutputStream?s)?throws?IOException?{
???synchronized(mutex)?{s.defaultWriteObject();}
????????}
????}
??????/**
?????*?
?????*?返回一個(gè)動(dòng)態(tài)的類型安全的集合。任何試圖插入錯(cuò)誤類型的元素的操作將立刻拋出
?????*?ClassCastException
?????*?動(dòng)態(tài)類型安全視圖的一個(gè)主要作用是用作debug調(diào)試，
?????*?因?yàn)樗苷_反映出出錯(cuò)的位置。
?????*?例如：ArrayList<String>?strings?=?new?ArrayList<String>();
?????*?ArrayList?rawList?=?strings;
?????*?rawList.add(new?Date());
?????*?add方法并不進(jìn)行類型檢查，所以存入了非String的對(duì)象。只有在重新獲取該對(duì)象
?????*?轉(zhuǎn)化為String類型的時(shí)候才拋出異常。
?????*?而動(dòng)態(tài)類型安全的集合能在add時(shí)就會(huì)拋出ClassCastException。
?????*?這種方法的優(yōu)點(diǎn)是錯(cuò)誤可以在正確的位置被報(bào)告
?????*?
?????*
?????*/
????public?static?<E>?Collection<E>?checkedCollection(Collection<E>?c,Class<E>?type)?{
????????return?new?CheckedCollection<E>(c,?type);
????}
????/**
?????*?@serial?include
?????*/
????static?class?CheckedCollection<E>?implements?Collection<E>,?Serializable?{
????????private?static?final?long?serialVersionUID?=?1578914078182001775L;
????????final?Collection<E>?c;
????????final?Class<E>?type;
????????void?typeCheck(Object?o)?{
????????????if?(!type.isInstance(o))?//o是否能被轉(zhuǎn)換成type類型
????????????????throw?new?ClassCastException("Attempt?to?insert?"?+
???????????????????o.getClass()?+?"?element?into?collection?with?element?type?"
???????????????????+?type);
????????}
????????CheckedCollection(Collection<E>?c,?Class<E>?type)?{
????????????if?(c==null?||?type?==?null)
????????????????throw?new?NullPointerException();
????????????this.c?=?c;
????????????this.type?=?type;
????????}
????????public?int?size()???????????????????{?return?c.size();?}
????????public?boolean?isEmpty()????????????{?return?c.isEmpty();?}
????????public?boolean?contains(Object?o)???{?return?c.contains(o);?}
????????public?Object[]?toArray()???????????{?return?c.toArray();?}
????????public?<T>?T[]?toArray(T[]?a)???????{?return?c.toArray(a);?}
????????public?String?toString()????????????{?return?c.toString();?}
????????public?boolean?remove(Object?o)?????{?return?c.remove(o);?}
????????public?boolean?containsAll(Collection<?>?coll)?{
????????????return?c.containsAll(coll);
????????}
????????public?boolean?removeAll(Collection<?>?coll)?{
????????????return?c.removeAll(coll);
????????}
????????public?boolean?retainAll(Collection<?>?coll)?{
????????????return?c.retainAll(coll);
????????}
????????public?void?clear()?{
????????????c.clear();
????????}
????????public?Iterator<E>?iterator()?{
???return?new?Iterator<E>()?{
private?final?Iterator<E>?it?=?c.iterator();
public?boolean?hasNext()?{?return?it.hasNext();?}
public?E?next()??????????{?return?it.next();?}
public?void?remove()?????{????????it.remove();?}};
????????}
????????public?boolean?add(E?e){
????????????typeCheck(e);?//添加元素需要進(jìn)行類型檢查
????????????return?c.add(e);
????????}
????????public?boolean?addAll(Collection<??extends?E>?coll)?{
????????????E[]?a?=?null;
????????????try?{
????????????????a?=?coll.toArray(zeroLengthElementArray());?//根據(jù)zero數(shù)組的類型來轉(zhuǎn)換集合為數(shù)組。如果coll中含有其他類型這里就會(huì)拋出異常
????????????}?catch?(ArrayStoreException?e)?{
????????????????throw?new?ClassCastException();
????????????}
????????????boolean?result?=?false;
????????????for?(E?e?:?a)
????????????????result?|=?c.add(e);?//只要集合發(fā)生了改變就返回true
????????????return?result;
????????}
????????private?E[]?zeroLengthElementArray?=?null;?//?Lazily?initialized
????????/*
?????????*?We?don't?need?locking?or?volatile,?because?it's?OK?if?we?create
?????????*?several?zeroLengthElementArrays,?and?they're?immutable.
?????????*/
????????E[]?zeroLengthElementArray()?{
????????????if?(zeroLengthElementArray?==?null)
????????????????zeroLengthElementArray?=?(E[])?Array.newInstance(type,?0);
????????????return?zeroLengthElementArray;
????????}
????}
????/**
?????*?返回一個(gè)會(huì)檢查類型的集合Set
?????*/
????public?static?<E>?Set<E>?checkedSet(Set<E>?s,?Class<E>?type)?{
????????return?new?CheckedSet<E>(s,?type);
????}
????/**
?????*?@serial?include
?????*/
????static?class?CheckedSet<E>?extends?CheckedCollection<E>
?????????????????????????????????implements?Set<E>,?Serializable{
????????private?static?final?long?serialVersionUID?=?4694047833775013803L;
????????CheckedSet(Set<E>?s,?Class<E>?elementType)?{?super(s,?elementType);?}
????????public?boolean?equals(Object?o)?{?return?o?==?this?||?c.equals(o);?}
????????public?int?hashCode()???????????{?return?c.hashCode();?}
????}
轉(zhuǎn)載于:https://www.cnblogs.com/prctice/p/5479329.html
總結(jié)
以上是生活随笔為你收集整理的java 集合类源码分析--collections的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 想用花呗还信用卡怎么操作 日常使用注意
- 下一篇： eclipse tomcat内存设置