【Java集合源码剖析】Vector源码剖析

转载请注明出处：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现在已经基本不再使用。