一、前言
知识补充:Arrays.copyOf函数:
1
2
3
4
5
6
|
public static int [] copyOf( int [] original, int newLength) {
int [] copy = new int [newLength];
System.arraycopy(original, 0 , copy, 0 ,
Math.min(original.length, newLength));
return copy;
}
|
可见copyOf()在内部新建一个数组,调用arrayCopy()将original内容复制到copy中去,并且长度为newLength。返回copy;
继续看一下System.arraycopy函数:
1
2
3
|
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
|
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
该方法是用了native关键字,调用的为C++编写的底层函数,可见其为JDK中的底层函数。
二、Vector简介
1
2
3
|
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
|
- Vector类实现了一个可增长的对象数组,内部是以动态数组的形式来存储数据的。
- Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较低下。
- 继承了AbstractList,此类提供 List 接口的骨干实现,以最大限度地减少实现”随机访问”数据存储(如数组)支持的该接口所需的工作.对于连续的访问数据(如链表),应优先使用 AbstractSequentialList,而不是此类.
- 实现了List接口,意味着Vector元素是有序的,可以重复的,可以有null元素的集合.
- 实现了RandomAccess接口标识着其支持随机快速访问,实际上,我们查看RandomAccess源码可以看到,其实里面什么都没有定义.因为ArrayList底层是数组,那么随机快速访问是理所当然的,访问速度O(1).
- 实现了Cloneable接口,标识着可以它可以被复制.注意,ArrayList里面的clone()复制其实是浅复制
- 实现了Serializable 标识着集合可被序列化。
三、Vector源码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
|
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//保存Vector数据的数组
protected Object[] elementData;
//实际数据的数量
protected int elementCount;
//容量增长的系数
protected int capacityIncrement;
// Vector的序列版本号
private static final long serialVersionUID = -2767605614048989439L;
//指定Vector初始大小和增长系数的构造函数
public Vector( int initialCapacity, int capacityIncrement) {
super ();
if (initialCapacity < 0 )
throw new IllegalArgumentException( "Illegal Capacity: " +
initialCapacity);
this .elementData = new Object[initialCapacity];
this .capacityIncrement = capacityIncrement;
}
//指定初始容量的构造函数
public Vector( int initialCapacity) {
this (initialCapacity, 0 );
}
//Vector构造函数,默认容量为10
public Vector() {
this ( 10 );
}
//初始化一个指定集合数据的构造函数
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[]. class )
elementData = Arrays.copyOf(elementData, elementCount, Object[]. class );
}
//将Vector全部元素拷贝到anArray数组中
public synchronized void copyInto(Object[] anArray) {
System.arraycopy(elementData, 0 , anArray, 0 , elementCount);
}
//当前的数组中元素个数大于记录的元素个数时,重新赋值给当前数组所记录的元素
public synchronized void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {
elementData = Arrays.copyOf(elementData, elementCount);
}
}
//确定Vector的容量
public synchronized void ensureCapacity( int minCapacity) {
if (minCapacity > 0 ) {
// 将Vector的改变统计数+1
modCount++;
ensureCapacityHelper(minCapacity);
}
}
//确定容量的帮助函数,如果所需容量大于当前的容量时则执行扩容
private void ensureCapacityHelper( int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0 )
grow(minCapacity);
}
//数组所允许的最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 ;
//执行扩容函数
private void grow( int minCapacity) {
// overflow-conscious code
//记录当前容量
int oldCapacity = elementData.length;
//如果扩容系数大于0则新容量等于当前容量+扩容系数,如果扩容系数小于等于0则新容量等于当前容量的2倍
int newCapacity = oldCapacity + ((capacityIncrement > 0 ) ?
capacityIncrement : oldCapacity);
//如果新容量小于当前需要的容量,则把需要的容量赋值给需要扩容的新容量
if (newCapacity - minCapacity < 0 )
newCapacity = minCapacity;
//如果新扩容容量大于最大数组容量,则执行巨大扩容
if (newCapacity - MAX_ARRAY_SIZE > 0 )
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
//巨大扩容函数,如果所需容量大于最大数组容量,则返回int形最大值(2^31 -1),否则返回最大数组容量
private static int hugeCapacity( int minCapacity) {
if (minCapacity < 0 ) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//设置容量值为newSize,如果newSize大于当前容量,则扩容,否则newSize以后的所有元素置null
public synchronized void setSize( int newSize) {
modCount++;
if (newSize > elementCount) {
ensureCapacityHelper(newSize);
} else {
for ( int i = newSize ; i < elementCount ; i++) {
elementData[i] = null ;
}
}
elementCount = newSize;
}
//返回当前Vector的容量
public synchronized int capacity() {
return elementData.length;
}
//返回Vector元素的个数
public synchronized int size() {
return elementCount;
}
//Vector元素个数是否为0
public synchronized boolean isEmpty() {
return elementCount == 0 ;
}
//返回Vector元素的Enumeration,Enumeration 接口是Iterator迭代器的“古老版本”
//Enumeration接口中的方法名称难以记忆,而且没有Iterator的remove()方法。如果现在编写Java程序,应该尽量采用
//Iterator迭代器,而不是用Enumeration迭代器。
//之所以保留Enumeration接口的原因,主要为了照顾以前那些“古老”的程序,那些程序里大量使用Enumeration接口,如果新版
//本的Java里直接删除Enumeration接口,将会导致那些程序全部出错。
public Enumeration<E> elements() {
return new Enumeration<E>() {
int count = 0 ;
public boolean hasMoreElements() {
return count < elementCount;
}
public E nextElement() {
synchronized (Vector. this ) {
if (count < elementCount) {
return elementData(count++);
}
}
throw new NoSuchElementException( "Vector Enumeration" );
}
};
}
//返回Vector中是否包含对象o
public boolean contains(Object o) {
return indexOf(o, 0 ) >= 0 ;
}
// 查找并返回元素(o)在Vector中的索引值
public int indexOf(Object o) {
return indexOf(o, 0 );
}
// 从index位置开始向后查找元素(o)。
// 若找到,则返回元素的索引值;否则,返回-1
public synchronized int indexOf(Object o, int index) {
if (o == null ) {
for ( int i = index ; i < elementCount ; i++)
if (elementData[i]== null )
return i;
} else {
for ( int i = index ; i < elementCount ; i++)
if (o.equals(elementData[i]))
return i;
}
return - 1 ;
}
// 从后向前查找元素(o)。并返回元素的索引
public synchronized int lastIndexOf(Object o) {
return lastIndexOf(o, elementCount- 1 );
}
// 从index位置开始向前查找元素(o)。
// 若找到,则返回元素的索引值;否则,返回-1
public synchronized int lastIndexOf(Object o, int index) {
if (index >= elementCount)
throw new IndexOutOfBoundsException(index + " >= " + elementCount);
if (o == null ) {
for ( int i = index; i >= 0 ; i--)
if (elementData[i]== null )
return i;
} else {
for ( int i = index; i >= 0 ; i--)
if (o.equals(elementData[i]))
return i;
}
return - 1 ;
}
// 返回Vector中index位置的元素。
// 若index越界,则抛出异常
public synchronized E elementAt( int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
}
return elementData(index);
}
// 返回Vector中第0位置的元素。
public synchronized E firstElement() {
if (elementCount == 0 ) {
throw new NoSuchElementException();
}
return elementData( 0 );
}
// 返回Vector中最后一个元素。
public synchronized E lastElement() {
if (elementCount == 0 ) {
throw new NoSuchElementException();
}
return elementData(elementCount - 1 );
}
// 设置index位置的元素值为obj
public synchronized void setElementAt(E obj, int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
elementData[index] = obj;
}
//删除index位置处的元素
public synchronized void removeElementAt( int index) {
modCount++;
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
else if (index < 0 ) {
throw new ArrayIndexOutOfBoundsException(index);
}
int j = elementCount - index - 1 ;
if (j > 0 ) {
System.arraycopy(elementData, index + 1 , elementData, index, j);
}
elementCount--;
elementData[elementCount] = null ; /* to let gc do its work */
}
//在index位置插入元素obj
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}
//在vector后面添加对象obj
public synchronized void addElement(E obj) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = obj;
}
// 在Vector中查找并删除元素obj。
// 成功的话,返回true;否则,返回false。
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
//删除Vector中所有元素
public synchronized void removeAllElements() {
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;
elementCount = 0;
}
//返回Vector的克隆。 该副本将包含对内部数据数组的克隆的引用,而不是对此对象的原始内部数据数组的引用。
public synchronized Object clone() {
try {
@SuppressWarnings("unchecked")
Vector<E> v = (Vector<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, elementCount);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
//返回包含Vector所有元素的数组
public synchronized Object[] toArray() {
return Arrays.copyOf(elementData, elementCount);
}
// 返回Vector的模板数组。所谓模板数组,即可以将T设为任意的数据类型
@SuppressWarnings("unchecked")
public synchronized <T> T[] toArray(T[] a) {
// 若数组a的大小 < Vector的元素个数;
// 则新建一个T[]数组,数组大小是“Vector的元素个数”,并将“Vector”全部拷贝到新数组中
if (a.length < elementCount)
return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
// 若数组a的大小 >= Vector的元素个数;
// 则将Vector的全部元素都拷贝到数组a中。
System.arraycopy(elementData, 0, a, 0, elementCount);
if (a.length > elementCount)
a[elementCount] = null;
return a;
}
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
//获取index处的元素
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
//设置index处的元素为element,并返回被替换掉的元素
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
//Vector末尾添加元素
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
//移除Vector中第一个出现对象o的元素
public boolean remove(Object o) {
return removeElement(o);
}
//在index位置添加对象element
public void add(int index, E element) {
insertElementAt(element, index);
}
//移除index位置的元素
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}
// 清空Vector
public void clear() {
removeAllElements();
}
// Bulk Operations
// 返回Vector是否包含集合c
public synchronized boolean containsAll(Collection<?> c) {
return super.containsAll(c);
}
//在Vector末尾添加集合c
public synchronized boolean addAll(Collection<? extends E> c) {
modCount++;
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
return numNew != 0;
}
// 删除集合c的全部元素
public synchronized boolean removeAll(Collection<?> c) {
return super.removeAll(c);
}
// 删除“非集合c中的元素”
public synchronized boolean retainAll(Collection<?> c) {
return super.retainAll(c);
}
//在index位置添加集合c中的元素
public synchronized boolean addAll(int index, Collection<? extends E> c) {
modCount++;
if (index < 0 || index > elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
int numMoved = elementCount - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
elementCount += numNew;
return numNew != 0;
}
// 返回两个对象是否相等
public synchronized boolean equals(Object o) {
return super.equals(o);
}
// 计算哈希值
public synchronized int hashCode() {
return super.hashCode();
}
// 调用父类的toString()
public synchronized String toString() {
return super.toString();
}
// 获取Vector中fromIndex(包括)到toIndex(不包括)的子集
public synchronized List<E> subList(int fromIndex, int toIndex) {
return Collections.synchronizedList(super.subList(fromIndex, toIndex),
this);
}
// 删除Vector中fromIndex到toIndex的元素
protected synchronized void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = elementCount - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newElementCount = elementCount - (toIndex-fromIndex);
while (elementCount != newElementCount)
elementData[--elementCount] = null;
}
// java.io.Serializable的写入函数
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
final java.io.ObjectOutputStream.PutField fields = s.putFields();
final Object[] data;
synchronized (this) {
fields.put("capacityIncrement", capacityIncrement);
fields.put("elementCount", elementCount);
data = elementData.clone();
}
fields.put("elementData", data);
s.writeFields();
}
public synchronized ListIterator<E> listIterator(int index) {
if (index < 0 || index > elementCount)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
public synchronized ListIterator<E> listIterator() {
return new ListItr(0);
}
public synchronized Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
// Racy but within spec, since modifications are checked
// within or after synchronization in next/previous
return cursor != elementCount;
}
public E next() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor;
if (i >= elementCount)
throw new NoSuchElementException();
cursor = i + 1;
return elementData(lastRet = i);
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.remove(lastRet);
expectedModCount = modCount;
}
cursor = lastRet;
lastRet = -1;
}
@Override
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
synchronized (Vector.this) {
final int size = elementCount;
int i = cursor;
if (i >= size) {
return;
}
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) Vector.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
action.accept(elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
final class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public E previous() {
synchronized (Vector.this) {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
cursor = i;
return elementData(lastRet = i);
}
}
public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
synchronized (Vector.this) {
checkForComodification();
Vector.this.set(lastRet, e);
}
}
public void add(E e) {
int i = cursor;
synchronized (Vector.this) {
checkForComodification();
Vector.this.add(i, e);
expectedModCount = modCount;
}
cursor = i + 1;
lastRet = -1;
}
}
@Override
public synchronized void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int elementCount = this.elementCount;
for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public synchronized boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
// figure out which elements are to be removed
// any exception thrown from the filter predicate at this stage
// will leave the collection unmodified
int removeCount = 0;
final int size = elementCount;
final BitSet removeSet = new BitSet(size);
final int expectedModCount = modCount;
for (int i=0; modCount == expectedModCount && i < size; i++) {
@SuppressWarnings("unchecked")
final E element = (E) elementData[i];
if (filter.test(element)) {
removeSet.set(i);
removeCount++;
}
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
// shift surviving elements left over the spaces left by removed elements
final boolean anyToRemove = removeCount > 0;
if (anyToRemove) {
final int newSize = size - removeCount;
for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
i = removeSet.nextClearBit(i);
elementData[j] = elementData[i];
}
for (int k=newSize; k < size; k++) {
elementData[k] = null; // Let gc do its work
}
elementCount = newSize;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
return anyToRemove;
}
@Override
@SuppressWarnings("unchecked")
public synchronized void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final int expectedModCount = modCount;
final int size = elementCount;
for (int i=0; modCount == expectedModCount && i < size; i++) {
elementData[i] = operator.apply((E) elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
@SuppressWarnings("unchecked")
@Override
public synchronized void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, elementCount, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
@Override
public Spliterator<E> spliterator() {
return new VectorSpliterator<>(this, null, 0, -1, 0);
}
/** Similar to ArrayList Spliterator */
static final class VectorSpliterator<E> implements Spliterator<E> {
private final Vector<E> list;
private Object[] array;
private int index; // current index, modified on advance/split
private int fence; // -1 until used; then one past last index
private int expectedModCount; // initialized when fence set
/** Create new spliterator covering the given range */
VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
int expectedModCount) {
this .list = list;
this .array = array;
this .index = origin;
this .fence = fence;
this .expectedModCount = expectedModCount;
}
private int getFence() { // initialize on first use
int hi;
if ((hi = fence) < 0 ) {
synchronized (list) {
array = list.elementData;
expectedModCount = list.modCount;
hi = fence = list.elementCount;
}
}
return hi;
}
public Spliterator<E> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1 ;
return (lo >= mid) ? null :
new VectorSpliterator<E>(list, array, lo, index = mid,
expectedModCount);
}
@SuppressWarnings ( "unchecked" )
public boolean tryAdvance(Consumer<? super E> action) {
int i;
if (action == null )
throw new NullPointerException();
if (getFence() > (i = index)) {
index = i + 1 ;
action.accept((E)array[i]);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true ;
}
return false ;
}
@SuppressWarnings ( "unchecked" )
public void forEachRemaining(Consumer<? super E> action) {
int i, hi; // hoist accesses and checks from loop
Vector<E> lst; Object[] a;
if (action == null )
throw new NullPointerException();
if ((lst = list) != null ) {
if ((hi = fence) < 0 ) {
synchronized (lst) {
expectedModCount = lst.modCount;
a = array = lst.elementData;
hi = fence = lst.elementCount;
}
}
else
a = array;
if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
while (i < hi)
action.accept((E) a[i++]);
if (lst.modCount == expectedModCount)
return ;
}
}
throw new ConcurrentModificationException();
}
public long estimateSize() {
return ( long ) (getFence() - index);
}
public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}
}
|
四、总结
- Vector实际上是通过一个数组去保存数据的。当我们构造Vecotr时;若使用默认构造函数,则Vector的默认容量大小是10。
- 当Vector容量不足以容纳全部元素时,Vector的容量会增加。若容量增加系数 >0,则将容量的值增加“容量增加系数”;否则,将容量大小增加一倍。
- Vector的克隆函数,即是将全部元素克隆到一个数组中。
五、Vector遍历方式
1. 随机访问遍历,通过索引值去遍历
由于Vector实现了RandomAccess接口,它支持通过索引值去随机访问元素。
1
2
3
4
5
|
Integer value = null ;
int size = vec.size();
for ( int i= 0 ; i<size; i++) {
value = (Integer)vec.get(i);
}
|
2. 通过迭代器遍历。即通过Iterator去遍历
1
2
3
4
5
|
Integer value = null ;
Iterator<Integer> iterator = vec.iterator();
while (iterator.hasNext()) {
value = iterator.next();
}
|
3. 通过增强for循环去遍历
1
2
3
4
|
Integer value = null ;
for (Integer integ:vec) {
value = integ;
}
|
4. 通过Enumeration遍历
1
2
3
4
5
|
Integer value = null ;
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
value = (Integer)enu.nextElement();
}
|
测试这些遍历方式效率的代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
public class Test {
public static void main(String[] args) {
Vector<Integer> vector = new Vector<>();
for ( int i = 0 ; i < 100000 ; i++)
vector.add(i);
iteratorThroughRandomAccess(vector);
iteratorThroughIterator(vector);
iteratorThroughFor2(vector);
iteratorThroughEnumeration(vector);
}
public static void iteratorThroughRandomAccess(List list) {
long startTime, endTime;
startTime = System.currentTimeMillis();
for ( int i = 0 ; i < list.size(); i++) {
}
endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println( "iteratorThroughRandomAccess:" + time + " ms" );
}
public static void iteratorThroughIterator(List list) {
long startTime, endTime;
startTime = System.currentTimeMillis();
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
iterator.next();
}
endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println( "iteratorThroughIterator:" + time + " ms" );
}
public static void iteratorThroughFor2(List list) {
long startTime, endTime;
startTime = System.currentTimeMillis();
for (Object o : list) {
}
endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println( "iteratorThroughFor2:" + time + " ms" );
}
public static void iteratorThroughEnumeration(Vector vec) {
long startTime, endTime;
startTime = System.currentTimeMillis();
for (Enumeration enu = vec.elements(); enu.hasMoreElements(); ) {
enu.nextElement();
}
endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println( "iteratorThroughEnumeration:" + time + " ms" );
}
}
|
输出如下:
iteratorThroughRandomAccess:3 ms
iteratorThroughIterator:6 ms
iteratorThroughFor2:5 ms
iteratorThroughEnumeration:5 ms
所以:遍历Vector,使用索引的随机访问方式最快,使用迭代器最慢。
到此这篇关于Java基础之容器Vector详解的文章就介绍到这了,更多相关java容器Vector内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家!
原文链接:https://blog.csdn.net/u013277209/article/details/80376209