Vector源码剖析(四)

转载:http://blog.csdn.net/ns_code/article/details/35793865

Vector简介

Vector也是基于数组实现的,是一个动态数组,其容量能自动增长。

Vector是JDK1.0引入了,它的很多实现方法都加入了同步语句,因此是线程安全的(其实也只是相对安全,有些时候还是要加入同步语句来保证线程的安全),可以用于多线程环境。

Vector没有实现Serializable接口,因此它不支持序列化,实现了Cloneable接口,能被克隆,实现了RandomAccess接口,支持快速随机访问。

Vector源码剖析

Vector的源码如下(加入了比较详细的注释):

[java] view plain copy

  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现在已经基本不再使用。

发表评论

电子邮件地址不会被公开。 必填项已用*标注