轉載請注明出處：http://blog.csdn.net/ns_code/article/details/35793865

Vector也是基于數組實現的，是一個動態數組，其容量能自動增長。

Vector是JDK1.0引入了，它的很多實現方法都加入了同步語句，因此是線程安全的（其實也只是相對安全，有些時候還是要加入同步語句來保證線程的安全），可以用于多線程環境。

Vector沒有絲線Serializable接口，因此它不支持序列化，實現了Cloneable接口，能被克隆，實現了Randomaccess接口，支持快速隨機訪問。

Vector的源碼如下（加入了比較詳細的注釋）：

1. packagejava.util;
3. publicclassVector<E>
4. extendsAbstractList<E>
5. implementsList<E>,RandomAccess,Cloneable,java.io.Serializable
6. {
8. //保存Vector中數據的數組
9. PRotectedObject[]elementData;
11. //實際數據的數量
12. protectedintelementCount;
14. //容量增長系數
15. protectedintcapacityIncrement;
17. //Vector的序列版本號
18. privatestaticfinallongserialVersionUID=-2767605614048989439L;
20. //Vector構造函數。默認容量是10。
21. publicVector(){
22. this(10);
23. }
25. //指定Vector容量大小的構造函數
26. publicVector(intinitialCapacity){
27. this(initialCapacity,0);
28. }
30. //指定Vector"容量大小"和"增長系數"的構造函數
31. publicVector(intinitialCapacity,intcapacityIncrement){
32. super();
33. if(initialCapacity<0)
34. thrownewIllegalArgumentException("IllegalCapacity:"+
35. initialCapacity);
36. //新建一個數組，數組容量是initialCapacity
37. this.elementData=newObject[initialCapacity];
38. //設置容量增長系數
39. this.capacityIncrement=capacityIncrement;
40. }
42. //指定集合的Vector構造函數。
43. publicVector(Collection<?extendsE>c){
44. //獲取“集合(c)”的數組，并將其賦值給elementData
45. elementData=c.toArray();
46. //設置數組長度
47. elementCount=elementData.length;
48. //c.toArraymight(incorrectly)notreturnObject[](see6260652)
49. if(elementData.getClass()!=Object[].class)
50. elementData=Arrays.copyOf(elementData,elementCount,Object[].class);
51. }
53. //將數組Vector的全部元素都拷貝到數組anArray中
54. publicsynchronizedvoidcopyInto(Object[]anArray){
55. System.arraycopy(elementData,0,anArray,0,elementCount);
56. }
58. //將當前容量值設為=實際元素個數
59. publicsynchronizedvoidtrimToSize(){
60. modCount++;
61. intoldCapacity=elementData.length;
62. if(elementCount<oldCapacity){
63. elementData=Arrays.copyOf(elementData,elementCount);
64. }
65. }
67. //確認“Vector容量”的幫助函數
68. privatevoidensureCapacityHelper(intminCapacity){
69. intoldCapacity=elementData.length;
70. //當Vector的容量不足以容納當前的全部元素，增加容量大小。
71. //若容量增量系數>0(即capacityIncrement>0)，則將容量增大當capacityIncrement
72. //否則，將容量增大一倍。
73. if(minCapacity>oldCapacity){
74. Object[]oldData=elementData;
75. intnewCapacity=(capacityIncrement>0)?
76. (oldCapacity+capacityIncrement):(oldCapacity*2);
77. if(newCapacity<minCapacity){
78. newCapacity=minCapacity;
79. }
80. elementData=Arrays.copyOf(elementData,newCapacity);
81. }
82. }
84. //確定Vector的容量。
85. publicsynchronizedvoidensureCapacity(intminCapacity){
86. //將Vector的改變統計數+1
87. modCount++;
88. ensureCapacityHelper(minCapacity);
89. }
91. //設置容量值為newSize
92. publicsynchronizedvoidsetSize(intnewSize){
93. modCount++;
94. if(newSize>elementCount){
95. //若"newSize大于Vector容量"，則調整Vector的大小。
96. ensureCapacityHelper(newSize);
97. }else{
98. //若"newSize小于/等于Vector容量"，則將newSize位置開始的元素都設置為null
99. for(inti=newSize;i<elementCount;i++){
100. elementData[i]=null;
101. }
102. }
103. elementCount=newSize;
104. }
106. //返回“Vector的總的容量”
107. publicsynchronizedintcapacity(){
108. returnelementData.length;
109. }
111. //返回“Vector的實際大小”，即Vector中元素個數
112. publicsynchronizedintsize(){
113. returnelementCount;
114. }
116. //判斷Vector是否為空
117. publicsynchronizedbooleanisEmpty(){
118. returnelementCount==0;
119. }
121. //返回“Vector中全部元素對應的Enumeration”
122. publicEnumeration<E>elements(){
123. //通過匿名類實現Enumeration
124. returnnewEnumeration<E>(){
125. intcount=0;
127. //是否存在下一個元素
128. publicbooleanhasMoreElements(){
129. returncount<elementCount;
130. }
132. //獲取下一個元素
133. publicEnextElement(){
134. synchronized(Vector.this){
135. if(count<elementCount){
136. return(E)elementData[count++];
137. }
138. }
139. thrownewNoSuchElementException("VectorEnumeration");
140. }
141. };
142. }
144. //返回Vector中是否包含對象(o)
145. publicbooleancontains(Objecto){
146. returnindexOf(o,0)>=0;
147. }
150. //從index位置開始向后查找元素(o)。
151. //若找到，則返回元素的索引值；否則，返回-1
152. publicsynchronizedintindexOf(Objecto,intindex){
153. if(o==null){
154. //若查找元素為null，則正向找出null元素，并返回它對應的序號
155. for(inti=index;i<elementCount;i++)
156. if(elementData[i]==null)
157. returni;
158. }else{
159. //若查找元素不為null，則正向找出該元素，并返回它對應的序號
160. for(inti=index;i<elementCount;i++)
161. if(o.equals(elementData[i]))
162. returni;
163. }
164. return-1;
165. }
167. //查找并返回元素(o)在Vector中的索引值
168. publicintindexOf(Objecto){
169. returnindexOf(o,0);
170. }
172. //從后向前查找元素(o)。并返回元素的索引
173. publicsynchronizedintlastIndexOf(Objecto){
174. returnlastIndexOf(o,elementCount-1);
175. }
177. //從后向前查找元素(o)。開始位置是從前向后的第index個數；
178. //若找到，則返回元素的“索引值”；否則，返回-1。
179. publicsynchronizedintlastIndexOf(Objecto,intindex){
180. if(index>=elementCount)
181. thrownewIndexOutOfBoundsException(index+">="+elementCount);
183. if(o==null){
184. //若查找元素為null，則反向找出null元素，并返回它對應的序號
185. for(inti=index;i>=0;i--)
186. if(elementData[i]==null)
187. returni;
188. }else{
189. //若查找元素不為null，則反向找出該元素，并返回它對應的序號
190. for(inti=index;i>=0;i--)
191. if(o.equals(elementData[i]))
192. returni;
193. }
194. return-1;
195. }
197. //返回Vector中index位置的元素。
198. //若index月結，則拋出異常
199. publicsynchronizedEelementAt(intindex){
200. if(index>=elementCount){
201. thrownewArrayIndexOutOfBoundsException(index+">="+elementCount);
202. }
204. return(E)elementData[index];
205. }
207. //獲取Vector中的第一個元素。
208. //若失敗，則拋出異常！
209. publicsynchronizedEfirstElement(){
210. if(elementCount==0){
211. thrownewNoSuchElementException();
212. }
213. return(E)elementData[0];
214. }
216. //獲取Vector中的最后一個元素。
217. //若失敗，則拋出異常！
218. publicsynchronizedElastElement(){
219. if(elementCount==0){
220. thrownewNoSuchElementException();
221. }
222. return(E)elementData[elementCount-1];
223. }
225. //設置index位置的元素值為obj
226. publicsynchronizedvoidsetElementAt(Eobj,intindex){
227. if(index>=elementCount){
228. thrownewArrayIndexOutOfBoundsException(index+">="+
229. elementCount);
230. }
231. elementData[index]=obj;
232. }
234. //刪除index位置的元素
235. publicsynchronizedvoidremoveElementAt(intindex){
236. modCount++;
237. if(index>=elementCount){
238. thrownewArrayIndexOutOfBoundsException(index+">="+
239. elementCount);
240. }elseif(index<0){
241. thrownewArrayIndexOutOfBoundsException(index);
242. }
244. intj=elementCount-index-1;
245. if(j>0){
246. System.arraycopy(elementData,index+1,elementData,index,j);
247. }
248. elementCount--;
249. elementData[elementCount]=null;/*toletgcdoitswork*/
250. }
252. //在index位置處插入元素(obj)
253. publicsynchronizedvoidinsertElementAt(Eobj,intindex){
254. modCount++;
255. if(index>elementCount){
256. thrownewArrayIndexOutOfBoundsException(index
257. +">"+elementCount);
258. }
259. ensureCapacityHelper(elementCount+1);
260. System.arraycopy(elementData,index,elementData,index+1,elementCount-index);
261. elementData[index]=obj;
262. elementCount++;
263. }
265. //將“元素obj”添加到Vector末尾
266. publicsynchronizedvoidaddElement(Eobj){
267. modCount++;
268. ensureCapacityHelper(elementCount+1);
269. elementData[elementCount++]=obj;
270. }
272. //在Vector中查找并刪除元素obj。
273. //成功的話，返回true；否則，返回false。
274. publicsynchronizedbooleanremoveElement(Objectobj){
275. modCount++;
276. inti=indexOf(obj);
277. if(i>=0){
278. removeElementAt(i);
279. returntrue;
280. }
281. returnfalse;
282. }
284. //刪除Vector中的全部元素
285. publicsynchronizedvoidremoveAllElements(){
286. modCount++;
287. //將Vector中的全部元素設為null
288. for(inti=0;i<elementCount;i++)
289. elementData[i]=null;
291. elementCount=0;
292. }
294. //克隆函數
295. publicsynchronizedObjectclone(){
296. try{
297. Vector<E>v=(Vector<E>)super.clone();
298. //將當前Vector的全部元素拷貝到v中
299. v.elementData=Arrays.copyOf(elementData,elementCount);
300. v.modCount=0;
301. returnv;
302. }catch(CloneNotSupportedExceptione){
303. //thisshouldn'thappen,sinceweareCloneable
304. thrownewInternalError();
305. }
306. }
308. //返回Object數組
309. publicsynchronizedObject[]toArray(){
310. returnArrays.copyOf(elementData,elementCount);
311. }
313. //返回Vector的模板數組。所謂模板數組，即可以將T設為任意的數據類型
314. publicsynchronized<T>T[]toArray(T[]a){
315. //若數組a的大小<Vector的元素個數；
316. //則新建一個T[]數組，數組大小是“Vector的元素個數”，并將“Vector”全部拷貝到新數組中
317. if(a.length<elementCount)
318. return(T[])Arrays.copyOf(elementData,elementCount,a.getClass());
320. //若數組a的大小>=Vector的元素個數；
321. //則將Vector的全部元素都拷貝到數組a中。
322. System.arraycopy(elementData,0,a,0,elementCount);
324. if(a.length>elementCount)
325. a[elementCount]=null;
327. returna;
328. }
330. //獲取index位置的元素
331. publicsynchronizedEget(intindex){
332. if(index>=elementCount)
333. thrownewArrayIndexOutOfBoundsException(index);
335. return(E)elementData[index];
336. }
338. //設置index位置的值為element。并返回index位置的原始值
339. publicsynchronizedEset(intindex,Eelement){
340. if(index>=elementCount)
341. thrownewArrayIndexOutOfBoundsException(index);
343. ObjectoldValue=elementData[index];
344. elementData[index]=element;
345. return(E)oldValue;
346. }
348. //將“元素e”添加到Vector最后。
349. publicsynchronizedbooleanadd(Ee){
350. modCount++;
351. ensureCapacityHelper(elementCount+1);
352. elementData[elementCount++]=e;
353. returntrue;
354. }
356. //刪除Vector中的元素o
357. publicbooleanremove(Objecto){
358. returnremoveElement(o);
359. }
361. //在index位置添加元素element
362. publicvoidadd(intindex,Eelement){
363. insertElementAt(element,index);
364. }
366. //刪除index位置的元素，并返回index位置的原始值
367. publicsynchronizedEremove(intindex){
368. modCount++;
369. if(index>=elementCount)
370. thrownewArrayIndexOutOfBoundsException(index);
371. ObjectoldValue=elementData[index];
373. intnumMoved=elementCount-index-1;
374. if(numMoved>0)
375. System.arraycopy(elementData,index+1,elementData,index,
376. numMoved);
377. elementData[--elementCount]=null;//Letgcdoitswork
379. return(E)oldValue;
380. }
382. //清空Vector
383. publicvoidclear(){
384. removeAllElements();
385. }
387. //返回Vector是否包含集合c
388. publicsynchronizedbooleancontainsAll(Collection<?>c){
389. returnsuper.containsAll(c);
390. }
392. //將集合c添加到Vector中
393. publicsynchronizedbooleanaddAll(Collection<?extendsE>c){
394. modCount++;
395. Object[]a=c.toArray();
396. intnumNew=a.length;
397. ensureCapacityHelper(elementCount+numNew);
398. //將集合c的全部元素拷貝到數組elementData中
399. System.arraycopy(a,0,elementData,elementCount,numNew);
400. elementCount+=numNew;
401. returnnumNew!=0;
402. }
404. //刪除集合c的全部元素
405. publicsynchronizedbooleanremoveAll(Collection<?>c){
406. returnsuper.removeAll(c);
407. }
409. //刪除“非集合c中的元素”
410. publicsynchronizedbooleanretainAll(Collection<?>c){
411. returnsuper.retainAll(c);
412. }
414. //從index位置開始，將集合c添加到Vector中
415. publicsynchronizedbooleanaddAll(intindex,Collection<?extendsE>c){
416. modCount++;
417. if(index<0||index>elementCount)
418. thrownewArrayIndexOutOfBoundsException(index);
420. Object[]a=c.toArray();
421. intnumNew=a.length;
422. ensureCapacityHelper(elementCount+numNew);
424. intnumMoved=elementCount-index;
425. if(numMoved>0)
426. System.arraycopy(elementData,index,elementData,index+numNew,numMoved);
428. System.arraycopy(a,0,elementData,index,numNew);
429. elementCount+=numNew;
430. returnnumNew!=0;
431. }
433. //返回兩個對象是否相等
434. publicsynchronizedbooleanequals(Objecto){
435. returnsuper.equals(o);
436. }
438. //計算哈希值
439. publicsynchronizedinthashCode(){
440. returnsuper.hashCode();
441. }
443. //調用父類的toString()
444. publicsynchronizedStringtoString(){
445. returnsuper.toString();
446. }
448. //獲取Vector中fromIndex(包括)到toIndex(不包括)的子集
449. publicsynchronizedList<E>subList(intfromIndex,inttoIndex){
450. returnCollections.synchronizedList(super.subList(fromIndex,toIndex),this);
451. }
453. //刪除Vector中fromIndex到toIndex的元素
454. protectedsynchronizedvoidremoveRange(intfromIndex,inttoIndex){
455. modCount++;
456. intnumMoved=elementCount-toIndex;
457. System.arraycopy(elementData,toIndex,elementData,fromIndex,
458. numMoved);
460. //Letgcdoitswork
461. intnewElementCount=elementCount-(toIndex-fromIndex);
462. while(elementCount!=newElementCount)
463. elementData[--elementCount]=null;
464. }
466. //java.io.Serializable的寫入函數
467. privatesynchronizedvoidwriteObject(java.io.ObjectOutputStreams)
468. throwsjava.io.IOException{
469. s.defaultWriteObject();
470. }
471. }

Vector的源碼實現總體與ArrayList類似，關于Vector的源碼，給出如下幾點總結：

1、Vector有四個不同的構造方法。無參構造方法的容量為默認值10，僅包含容量的構造方法則將容量增長量（從源碼中可以看出容量增長量的作用，第二點也會對容量增長量詳細說）明置為0。

2、注意擴充容量的方法ensureCapacityHelper。與 ArrayList相同，Vector在每次增加元素（可能是1個，也可能是一組）時，都要調用該方法來確保足夠的容量。當容量不足以容納當前的元素個數 時，就先看構造方法中傳入的容量增長量參數CapacityIncrement是否為0，如果不為0，就設置新的容量為就容量加上容量增長量，如果為0， 就設置新的容量為舊的容量的2倍，如果設置后的新容量還不夠，則直接新容量設置為傳入的參數（也就是所需的容量），而后同樣用Arrays.copyof()方法將元素拷貝到新的數組。

3、很多方法都加入了synchronized同步語句，來保證線程安全。

4、同樣在查找給定元素索引值等的方法中，源碼都將該元素的值分為null和不為null兩種情況處理，Vector中也允許元素為null。

5、其他很多地方都與ArrayList實現大同小異，Vector現在已經基本不再使用。