来看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的承继干系

2. java.lang.Object
3. java.util.AbstractCollection<E>
4. java.util.AbstractList<E>
5. java.util.Vector<E>
7. publicclassVector<E>
8. extendsAbstractList<E>
9. implementsList<E>,RandomAccess,Cloneable,java.io.Serializable{}

复制代码

Vector与Collection干系以下图：

登录/注册后可看大图

Vector的机关函数

2. Vector共有4个机关函数
3. //默许机关函数
4. Vector()
6. //capacity是Vector的默许容量巨细。当因为增添数据招致容量增添时，每次容量会增添一倍。
7. Vector(intcapacity)
9. //capacity是Vector的默许容量巨细，capacityIncrement是每次Vector容量增添时的增量值。
10. Vector(intcapacity,intcapacityIncrement)
12. //创立一个包括collection的Vector
13. Vector(Collection<?extendsE>collection)

复制代码

Vector的API

2. synchronizedbooleanadd(Eobject)
3. voidadd(intlocation,Eobject)
4. synchronizedbooleanaddAll(Collection<?extendsE>collection)
5. synchronizedbooleanaddAll(intlocation,Collection<?extendsE>collection)
6. synchronizedvoidaddElement(Eobject)
7. synchronizedintcapacity()
8. voidclear()
9. synchronizedObjectclone()
10. booleancontains(Objectobject)
11. synchronizedbooleancontainsAll(Collection<?>collection)
12. synchronizedvoidcopyInto(Object[]elements)
13. synchronizedEelementAt(intlocation)
14. Enumeration<E>elements()
15. synchronizedvoidensureCapacity(intminimumCapacity)
16. synchronizedbooleanequals(Objectobject)
17. synchronizedEfirstElement()
18. Eget(intlocation)
19. synchronizedinthashCode()
20. synchronizedintindexOf(Objectobject,intlocation)
21. intindexOf(Objectobject)
22. synchronizedvoidinsertElementAt(Eobject,intlocation)
23. synchronizedbooleanisEmpty()
24. synchronizedElastElement()
25. synchronizedintlastIndexOf(Objectobject,intlocation)
26. synchronizedintlastIndexOf(Objectobject)
27. synchronizedEremove(intlocation)
28. booleanremove(Objectobject)
29. synchronizedbooleanremoveAll(Collection<?>collection)
30. synchronizedvoidremoveAllElements()
31. synchronizedbooleanremoveElement(Objectobject)
32. synchronizedvoidremoveElementAt(intlocation)
33. synchronizedbooleanretainAll(Collection<?>collection)
34. synchronizedEset(intlocation,Eobject)
35. synchronizedvoidsetElementAt(Eobject,intlocation)
36. synchronizedvoidsetSize(intlength)
37. synchronizedintsize()
38. synchronizedList<E>subList(intstart,intend)
39. synchronized<T>T[]toArray(T[]contents)
40. synchronizedObject[]toArray()
41. synchronizedStringtoString()
42. synchronizedvoidtrimToSize()

复制代码

检察本栏目更多出色内容：http://www.bianceng.cn/Programming/Java/
第2部分Vector源码剖析
为了更懂得Vector的道理，上面对Vector源码代码作出剖析。

2. packagejava.util;
4. publicclassVector<E>
5. extendsAbstractList<E>
6. implementsList<E>,RandomAccess,Cloneable,java.io.Serializable
7. {
9. //保留Vector中数据的数组
10. protectedObject[]elementData;
12. //实践数据的数目
13. protectedintelementCount;
15. //容量增加系数
16. protectedintcapacityIncrement;
18. //Vector的序列版本号
19. privatestaticfinallongserialVersionUID=-2767605614048989439L;
21. //Vector机关函数。默许容量是10。
22. publicVector(){
23. this(10);
24. }
26. //指定Vector容量巨细的机关函数
27. publicVector(intinitialCapacity){
28. this(initialCapacity,0);
29. }
31. //指定Vector"容量巨细"和"增加系数"的机关函数
32. publicVector(intinitialCapacity,intcapacityIncrement){
33. super();
34. if(initialCapacity<0)
35. thrownewIllegalArgumentException("IllegalCapacity:"+
36. initialCapacity);
37. //新建一个数组，数组容量是initialCapacity
38. this.elementData=newObject[initialCapacity];
39. //设置容量增加系数
40. this.capacityIncrement=capacityIncrement;
41. }
43. //指定汇合的Vector机关函数。
44. publicVector(Collection<?extendsE>c){
45. //猎取“汇合(c)”的数组，并将其赋值给elementData
46. elementData=c.toArray();
47. //设置数组长度
48. elementCount=elementData.length;
49. //c.toArraymight(incorrectly)notreturnObject[](see6260652)
50. if(elementData.getClass()!=Object[].class)
51. elementData=Arrays.copyOf(elementData,elementCount,Object[].class);
52. }
54. //将数组Vector的全体元素都拷贝到数组anArray中
55. publicsynchronizedvoidcopyInto(Object[]anArray){
56. System.arraycopy(elementData,0,anArray,0,elementCount);
57. }
59. //将以后容量值设为=实践元素个数
60. publicsynchronizedvoidtrimToSize(){
61. modCount++;
62. intoldCapacity=elementData.length;
63. if(elementCount<oldCapacity){
64. elementData=Arrays.copyOf(elementData,elementCount);
65. }
66. }
68. //确认“Vector容量”的匡助函数
69. privatevoidensureCapacityHelper(intminCapacity){
70. intoldCapacity=elementData.length;
71. //当Vector的容量不敷以包容以后的全体元素，增添容量巨细。
72. //若容量增量系数>0(即capacityIncrement>0)，则将容量增年夜当capacityIncrement
73. //不然，将容量增年夜一倍。
74. if(minCapacity>oldCapacity){
75. Object[]oldData=elementData;
76. intnewCapacity=(capacityIncrement>0)?
77. (oldCapacity+capacityIncrement):(oldCapacity*2);
78. if(newCapacity<minCapacity){
79. newCapacity=minCapacity;
80. }
81. elementData=Arrays.copyOf(elementData,newCapacity);
82. }
83. }
85. //断定Vector的容量。
86. publicsynchronizedvoidensureCapacity(intminCapacity){
87. //将Vector的改动统计数+1
88. modCount++;
89. ensureCapacityHelper(minCapacity);
90. }
92. //设置容量值为newSize
93. publicsynchronizedvoidsetSize(intnewSize){
94. modCount++;
95. if(newSize>elementCount){
96. //若"newSize年夜于Vector容量"，则调剂Vector的巨细。
97. ensureCapacityHelper(newSize);
98. }else{
99. //若"newSize小于/即是Vector容量"，则将newSize地位入手下手的元素都设置为null
100. for(inti=newSize;i<elementCount;i++){
101. elementData[i]=null;
102. }
103. }
104. elementCount=newSize;
105. }
107. //前往“Vector的总的容量”
108. publicsynchronizedintcapacity(){
109. returnelementData.length;
110. }
112. //前往“Vector的实践巨细”，即Vector中元素个数
113. publicsynchronizedintsize(){
114. returnelementCount;
115. }
117. //判别Vector是不是为空
118. publicsynchronizedbooleanisEmpty(){
119. returnelementCount==0;
120. }
122. //前往“Vector中全体元素对应的Enumeration”
123. publicEnumeration<E>elements(){
124. //经由过程匿名类完成Enumeration
125. returnnewEnumeration<E>(){
126. intcount=0;
128. //是不是存鄙人一个元素
129. publicbooleanhasMoreElements(){
130. returncount<elementCount;
131. }
133. //猎取下一个元素
134. publicEnextElement(){
135. synchronized(Vector.this){
136. if(count<elementCount){
137. return(E)elementData[count++];
138. }
139. }
140. thrownewNoSuchElementException("VectorEnumeration");
141. }
142. };
143. }
145. //前往Vector中是不是包括对象(o)
146. publicbooleancontains(Objecto){
147. returnindexOf(o,0)>=0;
148. }
151. //从index地位入手下手向后查找元素(o)。
152. //若找到，则前往元素的索引值；不然，前往-1
153. publicsynchronizedintindexOf(Objecto,intindex){
154. if(o==null){
155. //若查找元素为null，则正向找出null元素，并前往它对应的序号
156. for(inti=index;i<elementCount;i++)
157. if(elementData[i]==null)
158. returni;
159. }else{
160. //若查找元素不为null，则正向找出该元素，并前往它对应的序号
161. for(inti=index;i<elementCount;i++)
162. if(o.equals(elementData[i]))
163. returni;
164. }
165. return-1;
166. }
168. //查找并前往元素(o)在Vector中的索引值
169. publicintindexOf(Objecto){
170. returnindexOf(o,0);
171. }
173. //从后向前查找元素(o)。并前往元素的索引
174. publicsynchronizedintlastIndexOf(Objecto){
175. returnlastIndexOf(o,elementCount-1);
176. }
178. //从后向前查找元素(o)。入手下手地位是夙昔向后的第index个数；
179. //若找到，则前往元素的“索引值”；不然，前往-1。
180. publicsynchronizedintlastIndexOf(Objecto,intindex){
181. if(index>=elementCount)
182. thrownewIndexOutOfBoundsException(index+">="+elementCount);
184. if(o==null){
185. //若查找元素为null，则反向找出null元素，并前往它对应的序号
186. for(inti=index;i>=0;i--)
187. if(elementData[i]==null)
188. returni;
189. }else{
190. //若查找元素不为null，则反向找出该元素，并前往它对应的序号
191. for(inti=index;i>=0;i--)
192. if(o.equals(elementData[i]))
193. returni;
194. }
195. return-1;
196. }
198. //前往Vector中index地位的元素。
199. //若index月结，则抛出非常
200. publicsynchronizedEelementAt(intindex){
201. if(index>=elementCount){
202. thrownewArrayIndexOutOfBoundsException(index+">="+elementCount);
203. }
205. return(E)elementData[index];
206. }
208. //猎取Vector中的第一个元素。
209. //若失利，则抛出非常！
210. publicsynchronizedEfirstElement(){
211. if(elementCount==0){
212. thrownewNoSuchElementException();
213. }
214. return(E)elementData[0];
215. }
217. //猎取Vector中的最初一个元素。
218. //若失利，则抛出非常！
219. publicsynchronizedElastElement(){
220. if(elementCount==0){
221. thrownewNoSuchElementException();
222. }
223. return(E)elementData[elementCount-1];
224. }
226. //设置index地位的元素值为obj
227. publicsynchronizedvoidsetElementAt(Eobj,intindex){
228. if(index>=elementCount){
229. thrownewArrayIndexOutOfBoundsException(index+">="+
230. elementCount);
231. }
232. elementData[index]=obj;
233. }
235. //删除index地位的元素
236. publicsynchronizedvoidremoveElementAt(intindex){
237. modCount++;
238. if(index>=elementCount){
239. thrownewArrayIndexOutOfBoundsException(index+">="+
240. elementCount);
241. }elseif(index<0){
242. thrownewArrayIndexOutOfBoundsException(index);
243. }
245. intj=elementCount-index-1;
246. if(j>0){
247. System.arraycopy(elementData,index+1,elementData,index,j);
248. }
249. elementCount--;
250. elementData[elementCount]=null;/*toletgcdoitswork*/
251. }
253. //在index地位处拔出元素(obj)
254. publicsynchronizedvoidinsertElementAt(Eobj,intindex){
255. modCount++;
256. if(index>elementCount){
257. thrownewArrayIndexOutOfBoundsException(index
258. +">"+elementCount);
259. }
260. ensureCapacityHelper(elementCount+1);
261. System.arraycopy(elementData,index,elementData,index+1,elementCount-index);
262. elementData[index]=obj;
263. elementCount++;
264. }
266. //将“元素obj”增加到Vector开端
267. publicsynchronizedvoidaddElement(Eobj){
268. modCount++;
269. ensureCapacityHelper(elementCount+1);
270. elementData[elementCount++]=obj;
271. }
273. //在Vector中查找并删除元素obj。
274. //乐成的话，前往true；不然，前往false。
275. publicsynchronizedbooleanremoveElement(Objectobj){
276. modCount++;
277. inti=indexOf(obj);
278. if(i>=0){
279. removeElementAt(i);
280. returntrue;
281. }
282. returnfalse;
283. }
285. //删除Vector中的全体元素
286. publicsynchronizedvoidremoveAllElements(){
287. modCount++;
288. //将Vector中的全体元素设为null
289. for(inti=0;i<elementCount;i++)
290. elementData[i]=null;
292. elementCount=0;
293. }
295. //克隆函数
296. publicsynchronizedObjectclone(){
297. try{
298. Vector<E>v=(Vector<E>)super.clone();
299. //将以后Vector的全体元素拷贝到v中
300. v.elementData=Arrays.copyOf(elementData,elementCount);
301. v.modCount=0;
302. returnv;
303. }catch(CloneNotSupportedExceptione){
304. //thisshouldnthappen,sinceweareCloneable
305. thrownewInternalError();
306. }
307. }
309. //前往Object数组
310. publicsynchronizedObject[]toArray(){
311. returnArrays.copyOf(elementData,elementCount);
312. }
314. //前往Vector的模板数组。所谓模板数组，便可以将T设为恣意的数据范例
315. publicsynchronized<T>T[]toArray(T[]a){
316. //若数组a的巨细<Vector的元素个数；
317. //则新建一个T[]数组，数组巨细是“Vector的元素个数”，并将“Vector”全体拷贝到新数组中
318. if(a.length<elementCount)
319. return(T[])Arrays.copyOf(elementData,elementCount,a.getClass());
321. //若数组a的巨细>=Vector的元素个数；
322. //则将Vector的全体元素都拷贝到数组a中。
323. System.arraycopy(elementData,0,a,0,elementCount);
325. if(a.length>elementCount)
326. a[elementCount]=null;
328. returna;
329. }
331. //猎取index地位的元素
332. publicsynchronizedEget(intindex){
333. if(index>=elementCount)
334. thrownewArrayIndexOutOfBoundsException(index);
336. return(E)elementData[index];
337. }
339. //设置index地位的值为element。并前往index地位的原始值
340. publicsynchronizedEset(intindex,Eelement){
341. if(index>=elementCount)
342. thrownewArrayIndexOutOfBoundsException(index);
344. ObjectoldValue=elementData[index];
345. elementData[index]=element;
346. return(E)oldValue;
347. }
349. //将“元素e”增加到Vector最初。
350. publicsynchronizedbooleanadd(Ee){
351. modCount++;
352. ensureCapacityHelper(elementCount+1);
353. elementData[elementCount++]=e;
354. returntrue;
355. }
357. //删除Vector中的元素o
358. publicbooleanremove(Objecto){
359. returnremoveElement(o);
360. }
362. //在index地位增加元素element
363. publicvoidadd(intindex,Eelement){
364. insertElementAt(element,index);
365. }
367. //删除index地位的元素，并前往index地位的原始值
368. publicsynchronizedEremove(intindex){
369. modCount++;
370. if(index>=elementCount)
371. thrownewArrayIndexOutOfBoundsException(index);
372. ObjectoldValue=elementData[index];
374. intnumMoved=elementCount-index-1;
375. if(numMoved>0)
376. System.arraycopy(elementData,index+1,elementData,index,
377. numMoved);
378. elementData[--elementCount]=null;//Letgcdoitswork
380. return(E)oldValue;
381. }
383. //清空Vector
384. publicvoidclear(){
385. removeAllElements();
386. }
388. //前往Vector是不是包括汇合c
389. publicsynchronizedbooleancontainsAll(Collection<?>c){
390. returnsuper.containsAll(c);
391. }
393. //将汇合c增加到Vector中
394. publicsynchronizedbooleanaddAll(Collection<?extendsE>c){
395. modCount++;
396. Object[]a=c.toArray();
397. intnumNew=a.length;
398. ensureCapacityHelper(elementCount+numNew);
399. //将汇合c的全体元素拷贝到数组elementData中
400. System.arraycopy(a,0,elementData,elementCount,numNew);
401. elementCount+=numNew;
402. returnnumNew!=0;
403. }
405. //删除汇合c的全体元素
406. publicsynchronizedbooleanremoveAll(Collection<?>c){
407. returnsuper.removeAll(c);
408. }
410. //删除“非汇合c中的元素”
411. publicsynchronizedbooleanretainAll(Collection<?>c){
412. returnsuper.retainAll(c);
413. }
415. //从index地位入手下手，将汇合c增加到Vector中
416. publicsynchronizedbooleanaddAll(intindex,Collection<?extendsE>c){
417. modCount++;
418. if(index<0||index>elementCount)
419. thrownewArrayIndexOutOfBoundsException(index);
421. Object[]a=c.toArray();
422. intnumNew=a.length;
423. ensureCapacityHelper(elementCount+numNew);
425. intnumMoved=elementCount-index;
426. if(numMoved>0)
427. System.arraycopy(elementData,index,elementData,index+numNew,numMoved);
429. System.arraycopy(a,0,elementData,index,numNew);
430. elementCount+=numNew;
431. returnnumNew!=0;
432. }
434. //前往两个对象是不是相称
435. publicsynchronizedbooleanequals(Objecto){
436. returnsuper.equals(o);
437. }
439. //盘算哈希值
440. publicsynchronizedinthashCode(){
441. returnsuper.hashCode();
442. }
444. //挪用父类的toString()
445. publicsynchronizedStringtoString(){
446. returnsuper.toString();
447. }
449. //猎取Vector中fromIndex(包含)到toIndex(不包含)的子集
450. publicsynchronizedList<E>subList(intfromIndex,inttoIndex){
451. returnCollections.synchronizedList(super.subList(fromIndex,toIndex),this);
452. }
454. //删除Vector中fromIndex到toIndex的元素
455. protectedsynchronizedvoidremoveRange(intfromIndex,inttoIndex){
456. modCount++;
457. intnumMoved=elementCount-toIndex;
458. System.arraycopy(elementData,toIndex,elementData,fromIndex,
459. numMoved);
461. //Letgcdoitswork
462. intnewElementCount=elementCount-(toIndex-fromIndex);
463. while(elementCount!=newElementCount)
464. elementData[--elementCount]=null;
465. }
467. //java.io.Serializable的写进函数
468. privatesynchronizedvoidwriteObject(java.io.ObjectOutputStreams)
469. throwsjava.io.IOException{
470. s.defaultWriteObject();
471. }
472. }

复制代码

总结：
(01)Vector实践上是经由过程一个数组往保留数据的。当我们机关Vecotr时；若利用默许机关函数，则Vector的默许容量巨细是10。
(02)当Vector容量不敷以包容全体元素时，Vector的容量会增添。若容量增添系数>0，则将容量的值增添“容量增添系数”；不然，将容量巨细增添一倍。
(03)Vector的克隆函数，便是将全体元素克隆到一个数组中。
<p>
IDE是好。java中的IDE更是百花齐放，你用jbuilder能说jbuilder赶不上vs吗？用eclipse，netbeans也很舒服啊。我就不明白“稍微差一些”那一些是从哪里差来的。

是一种简化的C++语言 是一种安全的语言，具有阻绝计算机病毒传输的功能

至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。

Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台

那么我书也看了，程序也做了，别人问我的问题我都能解决了，是不是就成为高手了呢？当然没那么简单，这只是万里长征走完了第一步。不信？那你出去接一个项目，你知道怎么下手吗，你知道怎么设计吗，你知道怎么组织人员进行开发吗？你现在脑子里除了一些散乱的代码之外，可能再没有别的东西了吧！

不过，每次的执行编译后的字节码需要消耗一定的时间，这同时也在一定程度上降低了 Java 程序的运行效率。

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

Java 编程语言的风格十分接近C、C++语言。