来看Java汇合进修（六） Vector具体先容(源码剖析)和利用示例
如果你学习的是市场营销，是销售，也许参加大课堂的学习会更合适，因为你的工作能力中有个基础就是搭建自己的人脉，学完ArrayList和LinkedList以后，我们接着进修Vector。进修体例仍是和之前一样，先对Vector有个全体熟悉，然后再进修它的源码；最初再经由过程实例来学会利用它。
第1部分Vector先容
Vector简介
Vector是矢量行列，它是JDK1.0版本增加的类。承继于AbstractList，完成了List,RandomAccess,Cloneable这些接口。
Vector承继了AbstractList，完成了List；以是，它是一个行列，撑持相干的增加、删除、修正、遍历等功效。
Vector完成了RandmoAccess接口，即供应了随机会见功效。RandmoAccess是java顶用来被List完成，为List供应疾速会见功效的。在Vector中，我们便可以经由过程元素的序号疾速猎取元素对象；这就是疾速随机会见。
Vector完成了Cloneable接口，即完成clone()函数。它能被克隆。
和ArrayList分歧，Vector中的操纵是线程平安的；可是，Vector不撑持序列化，即没有完成java.io.Serializable接口。
Vector的承继干系
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.Vector<E>
publicclassVector<E>
extendsAbstractList<E>
implementsList<E>,RandomAccess,Cloneable,java.io.Serializable{}Vector与Collection干系以下图：
Vector的机关函数
Vector共有4个机关函数
//默许机关函数
Vector()
//capacity是Vector的默许容量巨细。当因为增添数据招致容量增添时，每次容量会增添一倍。
Vector(intcapacity)
//capacity是Vector的默许容量巨细，capacityIncrement是每次Vector容量增添时的增量值。
Vector(intcapacity,intcapacityIncrement)
//创立一个包括collection的Vector
Vector(Collection<?extendsE>collection)Vector的API
synchronizedbooleanadd(Eobject)
voidadd(intlocation,Eobject)
synchronizedbooleanaddAll(Collection<?extendsE>collection)
synchronizedbooleanaddAll(intlocation,Collection<?extendsE>collection)
synchronizedvoidaddElement(Eobject)
synchronizedintcapacity()
voidclear()
synchronizedObjectclone()
booleancontains(Objectobject)
synchronizedbooleancontainsAll(Collection<?>collection)
synchronizedvoidcopyInto(Object[]elements)
synchronizedEelementAt(intlocation)
Enumeration<E>elements()
synchronizedvoidensureCapacity(intminimumCapacity)
synchronizedbooleanequals(Objectobject)
synchronizedEfirstElement()
Eget(intlocation)
synchronizedinthashCode()
synchronizedintindexOf(Objectobject,intlocation)
intindexOf(Objectobject)
synchronizedvoidinsertElementAt(Eobject,intlocation)
synchronizedbooleanisEmpty()
synchronizedElastElement()
synchronizedintlastIndexOf(Objectobject,intlocation)
synchronizedintlastIndexOf(Objectobject)
synchronizedEremove(intlocation)
booleanremove(Objectobject)
synchronizedbooleanremoveAll(Collection<?>collection)
synchronizedvoidremoveAllElements()
synchronizedbooleanremoveElement(Objectobject)
synchronizedvoidremoveElementAt(intlocation)
synchronizedbooleanretainAll(Collection<?>collection)
synchronizedEset(intlocation,Eobject)
synchronizedvoidsetElementAt(Eobject,intlocation)
synchronizedvoidsetSize(intlength)
synchronizedintsize()
synchronizedList<E>subList(intstart,intend)
synchronized<T>T[]toArray(T[]contents)
synchronizedObject[]toArray()
synchronizedStringtoString()
synchronizedvoidtrimToSize()检察本栏目更多出色内容：http://www.bianceng.cn/Programming/Java/
第2部分Vector源码剖析
为了更懂得Vector的道理，上面对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;
//设置容量增加系数
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=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;
}
}
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==null)
returni;
}else{
//若查找元素不为null，则正向找出该元素，并前往它对应的序号
for(inti=index;i<elementCount;i++)
if(o.equals(elementData))
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==null)
returni;
}else{
//若查找元素不为null，则反向找出该元素，并前往它对应的序号
for(inti=index;i>=0;i--)
if(o.equals(elementData))
returni;
}
return-1;
}
//前往Vector中index地位的元素。
//若index月结，则抛出非常
publicsynchronizedEelementAt(intindex){
if(index>=elementCount){
thrownewArrayIndexOutOfBoundsException(index+">="+elementCount);
}
return(E)elementData;
}
//猎取Vector中的第一个元素。
//若失利，则抛出非常！
publicsynchronizedEfirstElement(){
if(elementCount==0){
thrownewNoSuchElementException();
}
return(E)elementData;
}
//猎取Vector中的最初一个元素。
//若失利，则抛出非常！
publicsynchronizedElastElement(){
if(elementCount==0){
thrownewNoSuchElementException();
}
return(E)elementData;
}
//设置index地位的元素值为obj
publicsynchronizedvoidsetElementAt(Eobj,intindex){
if(index>=elementCount){
thrownewArrayIndexOutOfBoundsException(index+">="+
elementCount);
}
elementData=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=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=obj;
elementCount++;
}
//将“元素obj”增加到Vector开端
publicsynchronizedvoidaddElement(Eobj){
modCount++;
ensureCapacityHelper(elementCount+1);
elementData=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=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=null;
returna;
}
//猎取index地位的元素
publicsynchronizedEget(intindex){
if(index>=elementCount)
thrownewArrayIndexOutOfBoundsException(index);
return(E)elementData;
}
//设置index地位的值为element。并前往index地位的原始值
publicsynchronizedEset(intindex,Eelement){
if(index>=elementCount)
thrownewArrayIndexOutOfBoundsException(index);
ObjectoldValue=elementData;
elementData=element;
return(E)oldValue;
}
//将“元素e”增加到Vector最初。
publicsynchronizedbooleanadd(Ee){
modCount++;
ensureCapacityHelper(elementCount+1);
elementData=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;
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();
}
}总结：
(01)Vector实践上是经由过程一个数组往保留数据的。当我们机关Vecotr时；若利用默许机关函数，则Vector的默许容量巨细是10。
(02)当Vector容量不敷以包容全体元素时，Vector的容量会增添。若容量增添系数>0，则将容量的值增添“容量增添系数”；不然，将容量巨细增添一倍。
(03)Vector的克隆函数，便是将全体元素克隆到一个数组中。
<p>
IDE是好。java中的IDE更是百花齐放，你用jbuilder能说jbuilder赶不上vs吗？用eclipse，netbeans也很舒服啊。我就不明白“稍微差一些”那一些是从哪里差来的。 Java 编程语言的风格十分接近C、C++语言。 你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。 不过，每次的执行编译后的字节码需要消耗一定的时间，这同时也在一定程度上降低了 Java 程序的运行效率。 那么我书也看了，程序也做了，别人问我的问题我都能解决了，是不是就成为高手了呢？当然没那么简单，这只是万里长征走完了第一步。不信？那你出去接一个项目，你知道怎么下手吗，你知道怎么设计吗，你知道怎么组织人员进行开发吗？你现在脑子里除了一些散乱的代码之外，可能再没有别的东西了吧！ Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台 至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。 是一种简化的C++语言 是一种安全的语言，具有阻绝计算机病毒传输的功能
页:
[1]