来看Java汇合进修（六） Vector具体先容(源码剖析)和利用示例 - 仓酷云

packagejava.util;
publicclassVector<E>
extendsAbstractList<E>
implementsList<E>,RandomAccess,Cloneable,java.io.Serializable
{
//保留Vector中数据的数组
protectedObject[]elementData;
//实践数据的数目
protectedintelementCount;
//容量增加系数
protectedintcapacityIncrement;
//Vector的序列版本号
privatestaticfinallongserialVersionUID=-2767605614048989439L;
//Vector机关函数。默许容量是10。
publicVector(){
this(10);
}
//指定Vector容量巨细的机关函数
publicVector(intinitialCapacity){
this(initialCapacity,0);
}
//指定Vector"容量巨细"和"增加系数"的机关函数
publicVector(intinitialCapacity,intcapacityIncrement){
super();
if(initialCapacity<0)
thrownewIllegalArgumentException("IllegalCapacity:"+
initialCapacity);
//新建一个数组，数组容量是initialCapacity
this.elementData=newObject[initialCapacity];
//设置容量增加系数
this.capacityIncrement=capacityIncrement;
}
//指定汇合的Vector机关函数。
publicVector(Collection<?extendsE>c){
//猎取“汇合(c)”的数组，并将其赋值给elementData
elementData=c.toArray();
//设置数组长度
elementCount=elementData.length;
//c.toArraymight(incorrectly)notreturnObject[](see6260652)
if(elementData.getClass()!=Object[].class)
elementData=Arrays.copyOf(elementData,elementCount,Object[].class);
}
//将数组Vector的全体元素都拷贝到数组anArray中
publicsynchronizedvoidcopyInto(Object[]anArray){
System.arraycopy(elementData,0,anArray,0,elementCount);
}
//将以后容量值设为=实践元素个数
publicsynchronizedvoidtrimToSize(){
modCount++;
intoldCapacity=elementData.length;
if(elementCount<oldCapacity){
elementData=Arrays.copyOf(elementData,elementCount);
}
}
//确认“Vector容量”的匡助函数
privatevoidensureCapacityHelper(intminCapacity){
intoldCapacity=elementData.length;
//当Vector的容量不敷以包容以后的全体元素，增添容量巨细。
//若容量增量系数>0(即capacityIncrement>0)，则将容量增年夜当capacityIncrement
//不然，将容量增年夜一倍。
if(minCapacity>oldCapacity){
Object[]oldData=elementData;
intnewCapacity=(capacityIncrement>0)?
(oldCapacity+capacityIncrement):(oldCapacity*2);
if(newCapacity<minCapacity){
newCapacity=minCapacity;
}
elementData=Arrays.copyOf(elementData,newCapacity);
}
}
//断定Vector的容量。
publicsynchronizedvoidensureCapacity(intminCapacity){
//将Vector的改动统计数+1
modCount++;
ensureCapacityHelper(minCapacity);
}
//设置容量值为newSize
publicsynchronizedvoidsetSize(intnewSize){
modCount++;
if(newSize>elementCount){
//若"newSize年夜于Vector容量"，则调剂Vector的巨细。
ensureCapacityHelper(newSize);
}else{
//若"newSize小于/即是Vector容量"，则将newSize地位入手下手的元素都设置为null
for(inti=newSize;i<elementCount;i++){
elementData[i]=null;
}
}
elementCount=newSize;
}
//前往“Vector的总的容量”
publicsynchronizedintcapacity(){
returnelementData.length;
}
//前往“Vector的实践巨细”，即Vector中元素个数
publicsynchronizedintsize(){
returnelementCount;
}
//判别Vector是不是为空
publicsynchronizedbooleanisEmpty(){
returnelementCount==0;
}
//前往“Vector中全体元素对应的Enumeration”
publicEnumeration<E>elements(){
//经由过程匿名类完成Enumeration
returnnewEnumeration<E>(){
intcount=0;
//是不是存鄙人一个元素
publicbooleanhasMoreElements(){
returncount<elementCount;
}
//猎取下一个元素
publicEnextElement(){
synchronized(Vector.this){
if(count<elementCount){
return(E)elementData[count++];
}
}
thrownewNoSuchElementException("VectorEnumeration");
}
};
}
//前往Vector中是不是包括对象(o)
publicbooleancontains(Objecto){
returnindexOf(o,0)>=0;
}
//从index地位入手下手向后查找元素(o)。
//若找到，则前往元素的索引值；不然，前往-1
publicsynchronizedintindexOf(Objecto,intindex){
if(o==null){
//若查找元素为null，则正向找出null元素，并前往它对应的序号
for(inti=index;i<elementCount;i++)
if(elementData[i]==null)
returni;
}else{
//若查找元素不为null，则正向找出该元素，并前往它对应的序号
for(inti=index;i<elementCount;i++)
if(o.equals(elementData[i]))
returni;
}
return-1;
}
//查找并前往元素(o)在Vector中的索引值
publicintindexOf(Objecto){
returnindexOf(o,0);
}
//从后向前查找元素(o)。并前往元素的索引
publicsynchronizedintlastIndexOf(Objecto){
returnlastIndexOf(o,elementCount-1);
}
//从后向前查找元素(o)。入手下手地位是夙昔向后的第index个数；
//若找到，则前往元素的“索引值”；不然，前往-1。
publicsynchronizedintlastIndexOf(Objecto,intindex){
if(index>=elementCount)
thrownewIndexOutOfBoundsException(index+">="+elementCount);
if(o==null){
//若查找元素为null，则反向找出null元素，并前往它对应的序号
for(inti=index;i>=0;i--)
if(elementData[i]==null)
returni;
}else{
//若查找元素不为null，则反向找出该元素，并前往它对应的序号
for(inti=index;i>=0;i--)
if(o.equals(elementData[i]))
returni;
}
return-1;
}
//前往Vector中index地位的元素。
//若index月结，则抛出非常
publicsynchronizedEelementAt(intindex){
if(index>=elementCount){
thrownewArrayIndexOutOfBoundsException(index+">="+elementCount);
}
return(E)elementData[index];
}
//猎取Vector中的第一个元素。
//若失利，则抛出非常！
publicsynchronizedEfirstElement(){
if(elementCount==0){
thrownewNoSuchElementException();
}
return(E)elementData[0];
}
//猎取Vector中的最初一个元素。
//若失利，则抛出非常！
publicsynchronizedElastElement(){
if(elementCount==0){
thrownewNoSuchElementException();
}
return(E)elementData[elementCount-1];
}
//设置index地位的元素值为obj
publicsynchronizedvoidsetElementAt(Eobj,intindex){
if(index>=elementCount){
thrownewArrayIndexOutOfBoundsException(index+">="+
elementCount);
}
elementData[index]=obj;
}
//删除index地位的元素
publicsynchronizedvoidremoveElementAt(intindex){
modCount++;
if(index>=elementCount){
thrownewArrayIndexOutOfBoundsException(index+">="+
elementCount);
}elseif(index<0){
thrownewArrayIndexOutOfBoundsException(index);
}
intj=elementCount-index-1;
if(j>0){
System.arraycopy(elementData,index+1,elementData,index,j);
}
elementCount--;
elementData[elementCount]=null;/*toletgcdoitswork*/
}
//在index地位处拔出元素(obj)
publicsynchronizedvoidinsertElementAt(Eobj,intindex){
modCount++;
if(index>elementCount){
thrownewArrayIndexOutOfBoundsException(index
+">"+elementCount);
}
ensureCapacityHelper(elementCount+1);
System.arraycopy(elementData,index,elementData,index+1,elementCount-index);
elementData[index]=obj;
elementCount++;
}
//将“元素obj”增加到Vector开端
publicsynchronizedvoidaddElement(Eobj){
modCount++;
ensureCapacityHelper(elementCount+1);
elementData[elementCount++]=obj;
}
//在Vector中查找并删除元素obj。
//乐成的话，前往true；不然，前往false。
publicsynchronizedbooleanremoveElement(Objectobj){
modCount++;
inti=indexOf(obj);
if(i>=0){
removeElementAt(i);
returntrue;
}
returnfalse;
}
//删除Vector中的全体元素
publicsynchronizedvoidremoveAllElements(){
modCount++;
//将Vector中的全体元素设为null
for(inti=0;i<elementCount;i++)
elementData[i]=null;
elementCount=0;
}
//克隆函数
publicsynchronizedObjectclone(){
try{
Vector<E>v=(Vector<E>)super.clone();
//将以后Vector的全体元素拷贝到v中
v.elementData=Arrays.copyOf(elementData,elementCount);
v.modCount=0;
returnv;
}catch(CloneNotSupportedExceptione){
//thisshouldnthappen,sinceweareCloneable
thrownewInternalError();
}
}
//前往Object数组
publicsynchronizedObject[]toArray(){
returnArrays.copyOf(elementData,elementCount);
}
//前往Vector的模板数组。所谓模板数组，便可以将T设为恣意的数据范例
publicsynchronized<T>T[]toArray(T[]a){
//若数组a的巨细<Vector的元素个数；
//则新建一个T[]数组，数组巨细是“Vector的元素个数”，并将“Vector”全体拷贝到新数组中
if(a.length<elementCount)
return(T[])Arrays.copyOf(elementData,elementCount,a.getClass());
//若数组a的巨细>=Vector的元素个数；
//则将Vector的全体元素都拷贝到数组a中。
System.arraycopy(elementData,0,a,0,elementCount);
if(a.length>elementCount)
a[elementCount]=null;
returna;
}
//猎取index地位的元素
publicsynchronizedEget(intindex){
if(index>=elementCount)
thrownewArrayIndexOutOfBoundsException(index);
return(E)elementData[index];
}
//设置index地位的值为element。并前往index地位的原始值
publicsynchronizedEset(intindex,Eelement){
if(index>=elementCount)
thrownewArrayIndexOutOfBoundsException(index);
ObjectoldValue=elementData[index];
elementData[index]=element;
return(E)oldValue;
}
//将“元素e”增加到Vector最初。
publicsynchronizedbooleanadd(Ee){
modCount++;
ensureCapacityHelper(elementCount+1);
elementData[elementCount++]=e;
returntrue;
}
//删除Vector中的元素o
publicbooleanremove(Objecto){
returnremoveElement(o);
}
//在index地位增加元素element
publicvoidadd(intindex,Eelement){
insertElementAt(element,index);
}
//删除index地位的元素，并前往index地位的原始值
publicsynchronizedEremove(intindex){
modCount++;
if(index>=elementCount)
thrownewArrayIndexOutOfBoundsException(index);
ObjectoldValue=elementData[index];
intnumMoved=elementCount-index-1;
if(numMoved>0)
System.arraycopy(elementData,index+1,elementData,index,
numMoved);
elementData[--elementCount]=null;//Letgcdoitswork
return(E)oldValue;
}
//清空Vector
publicvoidclear(){
removeAllElements();
}
//前往Vector是不是包括汇合c
publicsynchronizedbooleancontainsAll(Collection<?>c){
returnsuper.containsAll(c);
}
//将汇合c增加到Vector中
publicsynchronizedbooleanaddAll(Collection<?extendsE>c){
modCount++;
Object[]a=c.toArray();
intnumNew=a.length;
ensureCapacityHelper(elementCount+numNew);
//将汇合c的全体元素拷贝到数组elementData中
System.arraycopy(a,0,elementData,elementCount,numNew);
elementCount+=numNew;
returnnumNew!=0;
}
//删除汇合c的全体元素
publicsynchronizedbooleanremoveAll(Collection<?>c){
returnsuper.removeAll(c);
}
//删除“非汇合c中的元素”
publicsynchronizedbooleanretainAll(Collection<?>c){
returnsuper.retainAll(c);
}
//从index地位入手下手，将汇合c增加到Vector中
publicsynchronizedbooleanaddAll(intindex,Collection<?extendsE>c){
modCount++;
if(index<0||index>elementCount)
thrownewArrayIndexOutOfBoundsException(index);
Object[]a=c.toArray();
intnumNew=a.length;
ensureCapacityHelper(elementCount+numNew);
intnumMoved=elementCount-index;
if(numMoved>0)
System.arraycopy(elementData,index,elementData,index+numNew,numMoved);
System.arraycopy(a,0,elementData,index,numNew);
elementCount+=numNew;
returnnumNew!=0;
}
//前往两个对象是不是相称
publicsynchronizedbooleanequals(Objecto){
returnsuper.equals(o);
}
//盘算哈希值
publicsynchronizedinthashCode(){
returnsuper.hashCode();
}
//挪用父类的toString()
publicsynchronizedStringtoString(){
returnsuper.toString();
}
//猎取Vector中fromIndex(包含)到toIndex(不包含)的子集
publicsynchronizedList<E>subList(intfromIndex,inttoIndex){
returnCollections.synchronizedList(super.subList(fromIndex,toIndex),this);
}
//删除Vector中fromIndex到toIndex的元素
protectedsynchronizedvoidremoveRange(intfromIndex,inttoIndex){
modCount++;
intnumMoved=elementCount-toIndex;
System.arraycopy(elementData,toIndex,elementData,fromIndex,
numMoved);
//Letgcdoitswork
intnewElementCount=elementCount-(toIndex-fromIndex);
while(elementCount!=newElementCount)
elementData[--elementCount]=null;
}
//java.io.Serializable的写进函数
privatesynchronizedvoidwriteObject(java.io.ObjectOutputStreams)
throwsjava.io.IOException{
s.defaultWriteObject();
}
}

复制代码