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

2023-02-13 21:45:52

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

上一篇：vector源码1(参考STL源码--侯捷):源码


下一篇：【Spring系列】Spring mvc整合redis(非集群)