【小笨鸟看JDK1.7集合源码之四】Vector源码剖析

  1 public class Vector<E>
  2     extends AbstractList<E>
  3     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  4 {
  5     /**
  6      * 数组缓冲区，用于存放vector中的元素
  7      */
  8     protected Object[] elementData;
  9 
 10     /**
 11      *元素个数，Vector 对象中的有效组件数。从 elementData[0] 到 elementData[elementCount-1] 
 12      的组件均为实际项。 
 13      */
 14     protected int elementCount;
 15 
 16     /**
 17      *向量的大小大于其容量时，容量自动增加的量。
 18      如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍，
 19      代表的是一个变化的增量，是在扩容时计算；
 20      */
 21     protected int capacityIncrement;
 22 
 23     /** use serialVersionUID from JDK 1.0.2 for interoperability */
 24     private static final long serialVersionUID = -2767605614048989439L;
 25     
 26     /**
 27     构造函数
 28     initialCapacity：初始容量
 29     capacityIncrement：容量的增量
 30     */
 31     public Vector(int initialCapacity, int capacityIncrement) {
 32         super();
 33         if (initialCapacity < 0)
 34             throw new IllegalArgumentException("Illegal Capacity: "+
 35                                                initialCapacity);
 36         this.elementData = new Object[initialCapacity];//初始化
 37         this.capacityIncrement = capacityIncrement;
 38     }
 39     //不带增量的构造函数
 40     public Vector(int initialCapacity) {
 41         this(initialCapacity, 0);
 42     }
 43     //无参构造函数，默认初始化容量为10，标准容量增量为0
 44     public Vector() {
 45         this(10);
 46     }
 47     /**构造一个包含指定collection中的元素的向量vector*/
 48     public Vector(Collection<? extends E> c) {
 49         elementData = c.toArray();//获取元素数组
 50         elementCount = elementData.length;//数组长度
 51         // c.toArray might (incorrectly) not return Object[] (see 6260652)
 52         //可能返回的是非数组的对象
 53         if (elementData.getClass() != Object[].class)//如果非数组类型的对象
 54             //重新复制构造一个新的数组
 55             elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
 56     }
 57     /**将向量复制到指定的参数数组中，此方法是同步的
 58         复制默认从第一个元素开始，长度为vector中的元素个数，全部复制到参数anArray中；
 59         如果参数数组为空或者容量不够、存储类型异常，会抛出相应异常
 60     */
 61     public synchronized void copyInto(Object[] anArray) {
 62         System.arraycopy(elementData, 0, anArray, 0, elementCount);
 63     }
 64     /**
 65      * 调整向量的实际容量，如果当前向量容量大于其当前大小，则通过复制数组的方式将
 66      容量更改为当前的实际大小。其实就是根据当前容量与向量元素的实际个数不等时作出相应的
 67      调整；
 68      */
 69     public synchronized void trimToSize() {
 70         modCount++;
 71         int oldCapacity = elementData.length;
 72         if (elementCount < oldCapacity) {
 73             elementData = Arrays.copyOf(elementData, elementCount);
 74         }
 75     }
 76     /**
 77      * 确认容量，是否能容纳指定参数大小的容量
 78      */
 79     public synchronized void ensureCapacity(int minCapacity) {
 80         if (minCapacity > 0) {
 81             modCount++;
 82             ensureCapacityHelper(minCapacity);
 83         }
 84     }
 85     /**
 86      * 确认是否要扩容，如果指定参数大于当前的实际容量，则直接扩容，以参数为默认大小。
 87      */
 88     private void ensureCapacityHelper(int minCapacity) {
 89         // overflow-conscious code
 90         if (minCapacity - elementData.length > 0)
 91             grow(minCapacity);
 92     }
 93     /**
 94      默认的最大的数组容量为Integer.MAX_VALUE - 8，不能超过此容量，不然JVM会抛出OutOfMemoryError；
 95      那8个字节主要是VM保留的字节，用于表示数组的长度，在JVM解析中。
 96      */
 97     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 98     
 99     //扩容
100     private void grow(int minCapacity) {
101         // overflow-conscious code
102         int oldCapacity = elementData.length;//当前数组的长度
103         //如果指定了增量且大于0，则直接以增量大小扩容，否则增量取当前数组的长度，即直接增加到原来的两倍
104         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
105                                          capacityIncrement : oldCapacity);
106         if (newCapacity - minCapacity < 0)//如果扩容后长度还是小于指定的最小参数minCapacity
107             newCapacity = minCapacity;//则以minCapacity参数大小扩容
108         if (newCapacity - MAX_ARRAY_SIZE > 0)//主要是为了防止内存溢出
109             newCapacity = hugeCapacity(minCapacity);
110         elementData = Arrays.copyOf(elementData, newCapacity);
111     }
112     //防止超出最大的数组范围，如果超出默认取最大值
113     private static int hugeCapacity(int minCapacity) {
114         if (minCapacity < 0) // overflow
115             throw new OutOfMemoryError();
116         return (minCapacity > MAX_ARRAY_SIZE) ?
117             Integer.MAX_VALUE :
118             MAX_ARRAY_SIZE;
119     }
120     /**
121      * 设置向量的大小
122      （1）如果设置的参数值大于向量的大小，则先扩容，再在后面补齐相应数量的null项
123      （2）如果设置的参数值小于向量的大小，则直接将多余的长度丢弃，后面的项也直接设置为null
124      */
125     public synchronized void setSize(int newSize) {
126         modCount++;
127         if (newSize > elementCount) {
128             ensureCapacityHelper(newSize);
129         } else {
130             for (int i = newSize ; i < elementCount ; i++) {
131                 elementData[i] = null;
132             }
133         }
134         elementCount = newSize;//更新长度，后面的null值项直接被回收
135     }
136     /**
137      *返回此向量的当前容量，也就是实际数组的长度
138      */
139     public synchronized int capacity() {
140         return elementData.length;
141     }
142     /**
143      * 返回此向量中的组件数
144      */
145     public synchronized int size() {
146         return elementCount;
147     }
148     /**
149      * 是否为空
150      */
151     public synchronized boolean isEmpty() {
152         return elementCount == 0;
153     }
154     /**
155      * 返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。
156      生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。 
157      */
158     public Enumeration<E> elements() {
159         return new Enumeration<E>() {
160             int count = 0;
161 
162             public boolean hasMoreElements() {
163                 return count < elementCount;
164             }
165 
166             public E nextElement() {
167                 synchronized (Vector.this) {
168                     if (count < elementCount) {
169                         return elementData(count++);
170                     }
171                 }
172                 throw new NoSuchElementException("Vector Enumeration");
173             }
174         };
175     }
176     /**
177      * 是否包含某个指定元素，此元素可以是null值
178      */
179     public boolean contains(Object o) {
180         return indexOf(o, 0) >= 0;
181     }
182     /**
183      * 返回指定元素第一次出现的索引，如果不包含返回-1
184      */
185     public int indexOf(Object o) {
186         return indexOf(o, 0);
187     }
188     /**
189      * 返回指定元素第一次出现的索引，从指定索引index开始查找，如果不包含返回-1；
190      注意一下，null值与普通值也是分开查找的
191      */
192     public synchronized int indexOf(Object o, int index) {
193         if (o == null) {
194             for (int i = index ; i < elementCount ; i++)
195                 if (elementData[i]==null)
196                     return i;
197         } else {
198             for (int i = index ; i < elementCount ; i++)
199                 if (o.equals(elementData[i]))
200                     return i;
201         }
202         return -1;
203     }
204     /**
205      *反向查找指定元素出现的第一次索引位置
206      */
207     public synchronized int lastIndexOf(Object o) {
208         return lastIndexOf(o, elementCount-1);//默认参数是最后一个元素的索引
209     }
210     /**
211      * 反向查找指定元素出现的第一次索引位置，从指定索引index处开始
212      */
213     public synchronized int lastIndexOf(Object o, int index) {
214         if (index >= elementCount)
215             throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
216         //也是将null值与普通元素分开查询
217         if (o == null) {
218             for (int i = index; i >= 0; i--)
219                 if (elementData[i]==null)
220                     return i;
221         } else {
222             for (int i = index; i >= 0; i--)
223                 if (o.equals(elementData[i]))
224                     return i;
225         }
226         return -1;
227     }
228     /**
229      * 返回指定索引处的元素
230      */
231     public synchronized E elementAt(int index) {
232         if (index >= elementCount) {
233             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
234         }
235 
236         return elementData(index);
237     }
238     /**
239      * 返回第一个元素组件
240      */
241     public synchronized E firstElement() {
242         if (elementCount == 0) {
243             throw new NoSuchElementException();
244         }
245         return elementData(0);
246     }
247     /**
248      * 返回最后一个元素组件
249      */
250     public synchronized E lastElement() {
251         if (elementCount == 0) {
252             throw new NoSuchElementException();
253         }
254         return elementData(elementCount - 1);
255     }
256 
257     /**
258      * 在指定的索引位置index处设置指定的新的值obj
259      */
260     public synchronized void setElementAt(E obj, int index) {
261         if (index >= elementCount) {
262             throw new ArrayIndexOutOfBoundsException(index + " >= " +
263                                                      elementCount);
264         }
265         elementData[index] = obj;
266     }
267 
268     /**
269      * 删除指定索引位置的组件。
270      */
271     public synchronized void removeElementAt(int index) {
272         modCount++;
273         if (index >= elementCount) {
274             throw new ArrayIndexOutOfBoundsException(index + " >= " +
275                                                      elementCount);
276         }
277         else if (index < 0) {
278             throw new ArrayIndexOutOfBoundsException(index);
279         }
280         int j = elementCount - index - 1;
281         if (j > 0) {//执行数组复制移位覆盖
282         /*假设数组元素为1-2-3-4-5，index=2，即从索引下标2移除，则elementCount=5，j=2
283         (1)elementData从index+1处开始取j个元素，即4-5
284         (2)从elementData指定索引index=2处开始覆盖，即1-2-4-5-5
285         (3)将最后的元素设置为null，被GC回收
286         */
287             System.arraycopy(elementData, index + 1, elementData, index, j);
288         }
289         elementCount--;//更新长度
290         elementData[elementCount] = null; /* to let gc do its work */
291     }
292 
293     /**
294      * 在指定索引处插入一个指定obj组件
295      */
296     public synchronized void insertElementAt(E obj, int index) {
297         modCount++;
298         if (index > elementCount) {
299             throw new ArrayIndexOutOfBoundsException(index
300                                                      + " > " + elementCount);
301         }
302         //先扩容，增量为1
303         ensureCapacityHelper(elementCount + 1);
304         //执行数组复制移位覆盖，index处为null值
305         System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
306         elementData[index] = obj;//给index处赋值
307         elementCount++;//更新长度
308     }
309 
310     /**
311      * 在末尾添加指定的组件
312      */
313     public synchronized void addElement(E obj) {
314         modCount++;
315         ensureCapacityHelper(elementCount + 1);//先扩容，增量为1
316         elementData[elementCount++] = obj;//直接在末尾添加一个元素，并且赋值
317     }
318 
319     /**
320      * 删除指定值的组件
321      */
322     public synchronized boolean removeElement(Object obj) {
323         modCount++;
324         int i = indexOf(obj);//先找到指定值的索引位置
325         if (i >= 0) {//如果存在，则直接调用删除指定索引位置方法删除
326             removeElementAt(i);
327             return true;
328         }
329         return false;
330     }
331 
332     /**
333      * 移除所有的组件
334      */
335     public synchronized void removeAllElements() {
336         modCount++;
337         // Let gc do its work，也就是将所有的元素都设置为null，之后由GC回收掉
338         for (int i = 0; i < elementCount; i++)
339             elementData[i] = null;
340 
341         elementCount = 0;
342     }
343 
344     /**
345      * 返回向量的一个副本。副本中将包含一个对内部数据数组副本的引用，
346      而非对此 Vector 对象的原始内部数据数组的引用。
347      */
348     public synchronized Object clone() {
349         try {
350             @SuppressWarnings("unchecked")
351                 Vector<E> v = (Vector<E>) super.clone();//产生一个新的vector对象
352                 //内部实际上是复制产生一个新的数组，将新的对象指向这个数组
353             v.elementData = Arrays.copyOf(elementData, elementCount);
354             v.modCount = 0;
355             return v;
356         } catch (CloneNotSupportedException e) {
357             // this shouldn‘t happen, since we are Cloneable
358             throw new InternalError();
359         }
360     }
361 
362     /**
363      * 返回一个数组，包含顺序存放的所有元素
364      */
365     public synchronized Object[] toArray() {
366         return Arrays.copyOf(elementData, elementCount);
367     }
368 
369     /**
370      * 运行时指定返回的数组类型
371      1、如果给定的数组长度小于向量中元素的个数，则返回一个复制的数组，类型为指定的类型，数组后面用null值填充；
372      2、如果给定的数组长度大于向量中元素的个数，则直接全部复制到数组中；
373      */
374     @SuppressWarnings("unchecked")
375     public synchronized <T> T[] toArray(T[] a) {
376         if (a.length < elementCount)//1
377             return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
378 
379         System.arraycopy(elementData, 0, a, 0, elementCount);//2
380 
381         if (a.length > elementCount)//填充null值
382             a[elementCount] = null;
383 
384         return a;
385     }
386 
387     // 返回指定位置的组件，其实与get(int)方法功能完全相同
388     @SuppressWarnings("unchecked")
389     E elementData(int index) {
390         return (E) elementData[index];
391     }
392 
393     /**
394      * 返回指定位置的元素
395      */
396     public synchronized E get(int index) {
397         if (index >= elementCount)
398             throw new ArrayIndexOutOfBoundsException(index);
399 
400         return elementData(index);
401     }
402 
403     /**
404      * 给指定索引index处设置指定值element
405      */
406     public synchronized E set(int index, E element) {
407         if (index >= elementCount)
408             throw new ArrayIndexOutOfBoundsException(index);
409 
410         E oldValue = elementData(index);
411         elementData[index] = element;//覆盖旧的值
412         return oldValue;//返回旧的值
413     }
414 
415     /**
416      * 在向量尾部添加一个指定元素e
417      */
418     public synchronized boolean add(E e) {
419         modCount++;
420         ensureCapacityHelper(elementCount + 1);//先扩容，增量为1
421         elementData[elementCount++] = e;//赋值
422         return true;
423     }
424 
425     /**
426      * 从向量头部开始移除匹配到的第一个指定元素o
427      */
428     public boolean remove(Object o) {
429         return removeElement(o);
430     }
431 
432     /**
433      * 在指定的索引位置index处添加指定新的值element
434      */
435     public void add(int index, E element) {
436         insertElementAt(element, index);
437     }
438 
439     /**
440      * 移除指定索引index处的元素，并且返回此元素
441      */
442     public synchronized E remove(int index) {
443         modCount++;
444         if (index >= elementCount)
445             throw new ArrayIndexOutOfBoundsException(index);
446         E oldValue = elementData(index);
447 
448         int numMoved = elementCount - index - 1;
449         if (numMoved > 0)
450             //实际上就是将index的后面元素集体往前面移动一个位置覆盖
451             System.arraycopy(elementData, index+1, elementData, index,
452                              numMoved);
453         elementData[--elementCount] = null; //再将最后一个元素值null回收掉
454 
455         return oldValue;
456     }
457 
458     /**
459      * 移除向量中所有的元素
460      */
461     public void clear() {
462         removeAllElements();
463     }
464 
465     /**
466      * 此向量是否包含指定组件的所有元素
467      */
468     public synchronized boolean containsAll(Collection<?> c) {
469         return super.containsAll(c);
470     }
471 
472     /**
473      * 将指定容器中的元素添加到此向量的尾部
474      */
475     public synchronized boolean addAll(Collection<? extends E> c) {
476         modCount++;
477         Object[] a = c.toArray();
478         int numNew = a.length;
479         ensureCapacityHelper(elementCount + numNew);//以参数中的元素长度为增量扩容
480         System.arraycopy(a, 0, elementData, elementCount, numNew);//产生新的数组
481         elementCount += numNew;//更新向量中元素的个数
482         return numNew != 0;
483     }
484 
485     /**
486      *移除向量中所有的元素
487      */
488     public synchronized boolean removeAll(Collection<?> c) {
489         return super.removeAll(c);
490     }
491 
492     /**
493      *只保留指定容器中包含的元素
494      */
495     public synchronized boolean retainAll(Collection<?> c) {
496         return super.retainAll(c);
497     }
498 
499     /**
500      *从指定的索引index处，将指定容器c中的所有元素插入到此向量中
501      */
502     public synchronized boolean addAll(int index, Collection<? extends E> c) {
503         modCount++;
504         if (index < 0 || index > elementCount)
505             throw new ArrayIndexOutOfBoundsException(index);
506 
507         Object[] a = c.toArray();
508         int numNew = a.length;
509         ensureCapacityHelper(elementCount + numNew);//先扩容，增量为指定容器中元素的长度
510 
511         int numMoved = elementCount - index;
512         if (numMoved > 0)//如果插入位置没有超过向量元素索引下标
513             System.arraycopy(elementData, index, elementData, index + numNew,
514                              numMoved);
515         //如果插入位置刚好在尾部
516         System.arraycopy(a, 0, elementData, index, numNew);
517         elementCount += numNew;
518         return numNew != 0;
519     }
520 
521     /**
522      * 比较指定对象与此向量的相等性。当且仅当指定的对象也是一个 List、两个 List 大小相同，
523      并且其中所有对应的元素对都相等 时才返回 true。（如果 (e1==null ? e2==null : e1.equals(e2))，
524      则两个元素 e1 和 e2 相等）。
525      换句话说，如果两个 List 包含相同顺序的相同元素，则这两个 List 就定义为相等。
526      */
527     public synchronized boolean equals(Object o) {
528         return super.equals(o);
529     }
530 
531     /**
532      * 返回此向量的hash值
533      */
534     public synchronized int hashCode() {
535         return super.hashCode();
536     }
537 
538     /**
539      * 返回此向量的字符串表示形式，其中包含每个元素的String表示形式
540      */
541     public synchronized String toString() {
542         return super.toString();
543     }
544 
545     /**
546      *返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
547      */
548     public synchronized List<E> subList(int fromIndex, int toIndex) {
549         return Collections.synchronizedList(super.subList(fromIndex, toIndex),
550                                             this);
551     }
552 
553     /**
554      * 移除向量中指定参数范围内的所有元素，元素范围为从 fromIndex（包括）到 toIndex（不包括）
555      */
556     protected synchronized void removeRange(int fromIndex, int toIndex) {
557         modCount++;
558         int numMoved = elementCount - toIndex;//如果numMoved小于0，会直接抛出异常
559         /**还是实际例子说明：向量中初始元素为 1，2，3，4，5，6 elementCount=6，
560         参数假设fromIndex=2，toIndex=4 则numMoved = 2；
561         (1)从toIndex=4(包含)开始取长度为numMoved = 2数组，即5,6
562         (2)从fromIndex=2(包含)开始用(1)中的数组覆盖，即1,2,5,6,5,6
563         (3)将最后的5，6设置为null，回收，实现了范围删除
564         */
565         System.arraycopy(elementData, toIndex, elementData, fromIndex,
566                          numMoved);
567 
568         // Let gc do its work
569         int newElementCount = elementCount - (toIndex-fromIndex);
570         while (elementCount != newElementCount)
571             elementData[--elementCount] = null;//将最后的元素设置为null，被GC回收
572     }
573 
574     /**
575      * 序列化写入函数
576      */
577     private void writeObject(java.io.ObjectOutputStream s)
578             throws java.io.IOException {
579         final java.io.ObjectOutputStream.PutField fields = s.putFields();
580         final Object[] data;
581         synchronized (this) {
582             fields.put("capacityIncrement", capacityIncrement);
583             fields.put("elementCount", elementCount);
584             data = elementData.clone();
585         }
586         fields.put("elementData", data);
587         s.writeFields();
588     }
589 
590     /**
591      * 迭代
592      */
593     public synchronized ListIterator<E> listIterator(int index) {
594         if (index < 0 || index > elementCount)
595             throw new IndexOutOfBoundsException("Index: "+index);
596         return new ListItr(index);
597     }
598 
599     /**
600      * Returns a list iterator over the elements in this list (in proper
601      * sequence).
602      *
603      * <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
604      *
605      * @see #listIterator(int)
606      */
607     public synchronized ListIterator<E> listIterator() {
608         return new ListItr(0);
609     }
610 
611     public synchronized Iterator<E> iterator() {
612         return new Itr();
613     }
614 
615     private class Itr implements Iterator<E> {
616         int cursor;       // 下一个要迭代元素的索引
617         int lastRet = -1; // 上一个元素的索引位置，lastRet永远比cursor小1，cursor位于开始位置0时，lastRet初始化为-1
618         int expectedModCount = modCount;
619 
620         public boolean hasNext() {
621             // 向量中后序是否还有元素可以迭代
622             return cursor != elementCount;
623         }
624 
625         public E next() {//同步的迭代下一个元素
626             synchronized (Vector.this) {
627                 checkForComodification();
628                 int i = cursor;
629                 if (i >= elementCount)
630                     throw new NoSuchElementException();
631                 cursor = i + 1;
632                 return elementData(lastRet = i);//每次迭代后更新前一个索引
633             }
634         }
635 
636         public void remove() {//移除前一个元素
637             if (lastRet == -1)
638                 throw new IllegalStateException();
639             synchronized (Vector.this) {
640                 checkForComodification();
641                 Vector.this.remove(lastRet);
642                 expectedModCount = modCount;
643             }
644             cursor = lastRet;
645             lastRet = -1;
646         }
647 
648         final void checkForComodification() {
649             if (modCount != expectedModCount)
650                 throw new ConcurrentModificationException();
651         }
652     }
653 
654     /**
655      * An optimized version of AbstractList.ListItr
656      */
657     final class ListItr extends Itr implements ListIterator<E> {
658         ListItr(int index) {
659             super();
660             cursor = index;//int cursor 下一个要迭代元素的索引
661         }
662 
663         public boolean hasPrevious() {//当前迭代的元素前面是否有元素，即是否为第一个元素
664             return cursor != 0;
665         }
666 
667         public int nextIndex() {//下一个要迭代元素的索引
668             return cursor;
669         }
670 
671         public int previousIndex() {//返回当前迭代元素的前一个元素的索引
672             return cursor - 1;
673         }
674 
675         public E previous() {//返回当前迭代元素的前一个元素
676             synchronized (Vector.this) {
677                 checkForComodification();
678                 int i = cursor - 1;
679                 if (i < 0)
680                     throw new NoSuchElementException();
681                 cursor = i;
682                 return elementData(lastRet = i);
683             }
684         }
685 
686         public void set(E e) {//在当前迭代的前面索引处设置指定元素值
687             if (lastRet == -1)
688                 throw new IllegalStateException();
689             synchronized (Vector.this) {
690                 checkForComodification();
691                 Vector.this.set(lastRet, e);//实际上内部调用的是设置元素，在指定位置
692             }
693         }
694 
695         public void add(E e) {//添加当前迭代的位置插入指定元素
696             int i = cursor;
697             synchronized (Vector.this) {
698                 checkForComodification();
699                 Vector.this.add(i, e);//实际上内部调用的是插入元素，在i位置
700                 expectedModCount = modCount;
701             }
702             cursor = i + 1;
703             lastRet = -1;
704         }
705     }
706 }