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