jaVA的vector的源码_Java 集合系列06之 Vector详细介绍(源码解析)和使用示例

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 }