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

转载请注明出处：http://blog.csdn.net/ns_code/article/details/35793865

 

Vector简介

Vector也是基于数组实现的，是一个动态数组，其容量能自动增长。

Vector是JDK1.0引入了，它的很多实现方法都加入了同步语句，因此是线程安全的（其实也只是相对安全，有些时候还是要加入同步语句来保证线程的安全），可以用于多线程环境。

Vector没有丝线Serializable接口，因此它不支持序列化，实现了Cloneable接口，能被克隆，实现了RandomAccess接口，支持快速随机访问。

Vector源码剖析

Vector的源码如下（加入了比较详细的注释）：

1. package java.util;
2. public class Vector<E>
3. extends AbstractList<E>
4. implements List<E>, RandomAccess, Cloneable, java.io.Serializable
5. {
6. // 保存Vector中数据的数组
7. protected Object[] elementData;
8. // 实际数据的数量
9. protected int elementCount;
10. // 容量增长系数
11. protected int capacityIncrement;
12. // Vector的序列版本号
13. private static final long serialVersionUID = -2767605614048989439L;
14. // Vector构造函数。默认容量是10。
15. public Vector() {
16. this(10);
17. }
18. // 指定Vector容量大小的构造函数
19. public Vector(int initialCapacity) {
20. this(initialCapacity, 0);
21. }
22. // 指定Vector"容量大小"和"增长系数"的构造函数
23. public Vector(int initialCapacity, int capacityIncrement) {
24. super();
25. if (initialCapacity < 0)
26. throw new IllegalArgumentException("Illegal Capacity: "+
27. initialCapacity);
28. // 新建一个数组，数组容量是initialCapacity
29. this.elementData = new Object[initialCapacity];
30. // 设置容量增长系数
31. this.capacityIncrement = capacityIncrement;
32. }
33. // 指定集合的Vector构造函数。
34. public Vector(Collection<? extends E> c) {
35. // 获取“集合(c)”的数组，并将其赋值给elementData
36. elementData = c.toArray();
37. // 设置数组长度
38. elementCount = elementData.length;
39. // c.toArray might (incorrectly) not return Object[] (see 6260652)
40. if (elementData.getClass() != Object[].class)
41. elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
42. }
43. // 将数组Vector的全部元素都拷贝到数组anArray中
44. public synchronized void copyInto(Object[] anArray) {
45. System.arraycopy(elementData, 0, anArray, 0, elementCount);
46. }
47. // 将当前容量值设为 =实际元素个数
48. public synchronized void trimToSize() {
49. modCount++;
50. int oldCapacity = elementData.length;
51. if (elementCount < oldCapacity) {
52. elementData = Arrays.copyOf(elementData, elementCount);
53. }
54. }
55. // 确认“Vector容量”的帮助函数
56. private void ensureCapacityHelper(int minCapacity) {
57. int oldCapacity = elementData.length;
58. // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
59. // 若 容量增量系数>0(即capacityIncrement>0)，则将容量增大当capacityIncrement
60. // 否则，将容量增大一倍。
61. if (minCapacity > oldCapacity) {
62. Object[] oldData = elementData;
63. int newCapacity = (capacityIncrement > 0) ?
64. (oldCapacity + capacityIncrement) : (oldCapacity * 2);
65. if (newCapacity < minCapacity) {
66. newCapacity = minCapacity;
67. }
68. elementData = Arrays.copyOf(elementData, newCapacity);
69. }
70. }
71. // 确定Vector的容量。
72. public synchronized void ensureCapacity(int minCapacity) {
73. // 将Vector的改变统计数+1
74. modCount++;
75. ensureCapacityHelper(minCapacity);
76. }
77. // 设置容量值为 newSize
78. public synchronized void setSize(int newSize) {
79. modCount++;
80. if (newSize > elementCount) {
81. // 若 "newSize 大于 Vector容量"，则调整Vector的大小。
82. ensureCapacityHelper(newSize);
83. } else {
84. // 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null
85. for (int i = newSize ; i < elementCount ; i++) {
86. elementData[i] = null;
87. }
88. }
89. elementCount = newSize;
90. }
91. // 返回“Vector的总的容量”
92. public synchronized int capacity() {
93. return elementData.length;
94. }
95. // 返回“Vector的实际大小”，即Vector中元素个数
96. public synchronized int size() {
97. return elementCount;
98. }
99. // 判断Vector是否为空
100. public synchronized boolean isEmpty() {
101. return elementCount == 0;
102. }
103. // 返回“Vector中全部元素对应的Enumeration”
104. public Enumeration<E> elements() {
105. // 通过匿名类实现Enumeration
106. return new Enumeration<E>() {
107. int count = 0;
108. // 是否存在下一个元素
109. public boolean hasMoreElements() {
110. return count < elementCount;
111. }
112. // 获取下一个元素
113. public E nextElement() {
114. synchronized (Vector.this) {
115. if (count < elementCount) {
116. return (E)elementData[count++];
117. }
118. }
119. throw new NoSuchElementException("Vector Enumeration");
120. }
121. };
122. }
123. // 返回Vector中是否包含对象(o)
124. public boolean contains(Object o) {
125. return indexOf(o, 0) >= 0;
126. }
127. // 从index位置开始向后查找元素(o)。
128. // 若找到，则返回元素的索引值；否则，返回-1
129. public synchronized int indexOf(Object o, int index) {
130. if (o == null) {
131. // 若查找元素为null，则正向找出null元素，并返回它对应的序号
132. for (int i = index ; i < elementCount ; i++)
133. if (elementData[i]==null)
134. return i;
135. } else {
136. // 若查找元素不为null，则正向找出该元素，并返回它对应的序号
137. for (int i = index ; i < elementCount ; i++)
138. if (o.equals(elementData[i]))
139. return i;
140. }
141. return -1;
142. }
143. // 查找并返回元素(o)在Vector中的索引值
144. public int indexOf(Object o) {
145. return indexOf(o, 0);
146. }
147. // 从后向前查找元素(o)。并返回元素的索引
148. public synchronized int lastIndexOf(Object o) {
149. return lastIndexOf(o, elementCount-1);
150. }
151. // 从后向前查找元素(o)。开始位置是从前向后的第index个数；
152. // 若找到，则返回元素的“索引值”；否则，返回-1。
153. public synchronized int lastIndexOf(Object o, int index) {
154. if (index >= elementCount)
155. throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
156. if (o == null) {
157. // 若查找元素为null，则反向找出null元素，并返回它对应的序号
158. for (int i = index; i >= 0; i--)
159. if (elementData[i]==null)
160. return i;
161. } else {
162. // 若查找元素不为null，则反向找出该元素，并返回它对应的序号
163. for (int i = index; i >= 0; i--)
164. if (o.equals(elementData[i]))
165. return i;
166. }
167. return -1;
168. }
169. // 返回Vector中index位置的元素。
170. // 若index月结，则抛出异常
171. public synchronized E elementAt(int index) {
172. if (index >= elementCount) {
173. throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
174. }
175. return (E)elementData[index];
176. }
177. // 获取Vector中的第一个元素。
178. // 若失败，则抛出异常！
179. public synchronized E firstElement() {
180. if (elementCount == 0) {
181. throw new NoSuchElementException();
182. }
183. return (E)elementData[0];
184. }
185. // 获取Vector中的最后一个元素。
186. // 若失败，则抛出异常！
187. public synchronized E lastElement() {
188. if (elementCount == 0) {
189. throw new NoSuchElementException();
190. }
191. return (E)elementData[elementCount - 1];
192. }
193. // 设置index位置的元素值为obj
194. public synchronized void setElementAt(E obj, int index) {
195. if (index >= elementCount) {
196. throw new ArrayIndexOutOfBoundsException(index + " >= " +
197. elementCount);
198. }
199. elementData[index] = obj;
200. }
201. // 删除index位置的元素
202. public synchronized void removeElementAt(int index) {
203. modCount++;
204. if (index >= elementCount) {
205. throw new ArrayIndexOutOfBoundsException(index + " >= " +
206. elementCount);
207. } else if (index < 0) {
208. throw new ArrayIndexOutOfBoundsException(index);
209. }
210. int j = elementCount - index - 1;
211. if (j > 0) {
212. System.arraycopy(elementData, index + 1, elementData, index, j);
213. }
214. elementCount--;
215. elementData[elementCount] = null; /* to let gc do its work */
216. }
217. // 在index位置处插入元素(obj)
218. public synchronized void insertElementAt(E obj, int index) {
219. modCount++;
220. if (index > elementCount) {
221. throw new ArrayIndexOutOfBoundsException(index
222. + " > " + elementCount);
223. }
224. ensureCapacityHelper(elementCount + 1);
225. System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
226. elementData[index] = obj;
227. elementCount++;
228. }
229. // 将“元素obj”添加到Vector末尾
230. public synchronized void addElement(E obj) {
231. modCount++;
232. ensureCapacityHelper(elementCount + 1);
233. elementData[elementCount++] = obj;
234. }
235. // 在Vector中查找并删除元素obj。
236. // 成功的话，返回true；否则，返回false。
237. public synchronized boolean removeElement(Object obj) {
238. modCount++;
239. int i = indexOf(obj);
240. if (i >= 0) {
241. removeElementAt(i);
242. return true;
243. }
244. return false;
245. }
246. // 删除Vector中的全部元素
247. public synchronized void removeAllElements() {
248. modCount++;
249. // 将Vector中的全部元素设为null
250. for (int i = 0; i < elementCount; i++)
251. elementData[i] = null;
252. elementCount = 0;
253. }
254. // 克隆函数
255. public synchronized Object clone() {
256. try {
257. Vector<E> v = (Vector<E>) super.clone();
258. // 将当前Vector的全部元素拷贝到v中
259. v.elementData = Arrays.copyOf(elementData, elementCount);
260. v.modCount = 0;
261. return v;
262. } catch (CloneNotSupportedException e) {
263. // this shouldn't happen, since we are Cloneable
264. throw new InternalError();
265. }
266. }
267. // 返回Object数组
268. public synchronized Object[] toArray() {
269. return Arrays.copyOf(elementData, elementCount);
270. }
271. // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
272. public synchronized <T> T[] toArray(T[] a) {
273. // 若数组a的大小 < Vector的元素个数；
274. // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中
275. if (a.length < elementCount)
276. return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
277. // 若数组a的大小 >= Vector的元素个数；
278. // 则将Vector的全部元素都拷贝到数组a中。
279. System.arraycopy(elementData, 0, a, 0, elementCount);
280. if (a.length > elementCount)
281. a[elementCount] = null;
282. return a;
283. }
284. // 获取index位置的元素
285. public synchronized E get(int index) {
286. if (index >= elementCount)
287. throw new ArrayIndexOutOfBoundsException(index);
288. return (E)elementData[index];
289. }
290. // 设置index位置的值为element。并返回index位置的原始值
291. public synchronized E set(int index, E element) {
292. if (index >= elementCount)
293. throw new ArrayIndexOutOfBoundsException(index);
294. Object oldValue = elementData[index];
295. elementData[index] = element;
296. return (E)oldValue;
297. }
298. // 将“元素e”添加到Vector最后。
299. public synchronized boolean add(E e) {
300. modCount++;
301. ensureCapacityHelper(elementCount + 1);
302. elementData[elementCount++] = e;
303. return true;
304. }
305. // 删除Vector中的元素o
306. public boolean remove(Object o) {
307. return removeElement(o);
308. }
309. // 在index位置添加元素element
310. public void add(int index, E element) {
311. insertElementAt(element, index);
312. }
313. // 删除index位置的元素，并返回index位置的原始值
314. public synchronized E remove(int index) {
315. modCount++;
316. if (index >= elementCount)
317. throw new ArrayIndexOutOfBoundsException(index);
318. Object oldValue = elementData[index];
319. int numMoved = elementCount - index - 1;
320. if (numMoved > 0)
321. System.arraycopy(elementData, index+1, elementData, index,
322. numMoved);
323. elementData[--elementCount] = null; // Let gc do its work
324. return (E)oldValue;
325. }
326. // 清空Vector
327. public void clear() {
328. removeAllElements();
329. }
330. // 返回Vector是否包含集合c
331. public synchronized boolean containsAll(Collection<?> c) {
332. return super.containsAll(c);
333. }
334. // 将集合c添加到Vector中
335. public synchronized boolean addAll(Collection<? extends E> c) {
336. modCount++;
337. Object[] a = c.toArray();
338. int numNew = a.length;
339. ensureCapacityHelper(elementCount + numNew);
340. // 将集合c的全部元素拷贝到数组elementData中
341. System.arraycopy(a, 0, elementData, elementCount, numNew);
342. elementCount += numNew;
343. return numNew != 0;
344. }
345. // 删除集合c的全部元素
346. public synchronized boolean removeAll(Collection<?> c) {
347. return super.removeAll(c);
348. }
349. // 删除“非集合c中的元素”
350. public synchronized boolean retainAll(Collection<?> c)  {
351. return super.retainAll(c);
352. }
353. // 从index位置开始，将集合c添加到Vector中
354. public synchronized boolean addAll(int index, Collection<? extends E> c) {
355. modCount++;
356. if (index < 0 || index > elementCount)
357. throw new ArrayIndexOutOfBoundsException(index);
358. Object[] a = c.toArray();
359. int numNew = a.length;
360. ensureCapacityHelper(elementCount + numNew);
361. int numMoved = elementCount - index;
362. if (numMoved > 0)
363. System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
364. System.arraycopy(a, 0, elementData, index, numNew);
365. elementCount += numNew;
366. return numNew != 0;
367. }
368. // 返回两个对象是否相等
369. public synchronized boolean equals(Object o) {
370. return super.equals(o);
371. }
372. // 计算哈希值
373. public synchronized int hashCode() {
374. return super.hashCode();
375. }
376. // 调用父类的toString()
377. public synchronized String toString() {
378. return super.toString();
379. }
380. // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集
381. public synchronized List<E> subList(int fromIndex, int toIndex) {
382. return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
383. }
384. // 删除Vector中fromIndex到toIndex的元素
385. protected synchronized void removeRange(int fromIndex, int toIndex) {
386. modCount++;
387. int numMoved = elementCount - toIndex;
388. System.arraycopy(elementData, toIndex, elementData, fromIndex,
389. numMoved);
390. // Let gc do its work
391. int newElementCount = elementCount - (toIndex-fromIndex);
392. while (elementCount != newElementCount)
393. elementData[--elementCount] = null;
394. }
395. // java.io.Serializable的写入函数
396. private synchronized void writeObject(java.io.ObjectOutputStream s)
397. throws java.io.IOException {
398. s.defaultWriteObject();
399. }
400. }

几点总结

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现在已经基本不再使用。