Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

什么是Vector

  1. Vector是矢量队列。它是jdk1.0版本添加的类 继承 AbstractList、实现 List, RandomAccess, Cloneable, java.io.Serializable 这些接口
  2. 继承 AbstractList，实现List.所有它是一个对队列。支持队列相关的操作
  3. Vector 实现 RandomAccess 所有提供随机访问功能，RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元 素对象；这就是快速随机访问。
  4. Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
  5. Vector 是线程安全的，但也导致了性能要低于ArrayList

    Vector继承关系图

    image.png

Vector源码解析

  1. package java.util;
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.StreamCorruptedException;
  6. import java.util.function.Consumer;
  7. import java.util.function.Predicate;
  8. import java.util.function.UnaryOperator;
  10. public class Vector<E>
  11.         extends AbstractList<E>
  12.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  13. {
  14.     //这就是存储数据的数组，注意啦这是一个动态的数组
  15.     protected Object[] elementData;
  17.     //当前元素的个数
  18.     protected int elementCount;
  20.     //容量增长系数，扩容时使用
  21.     protected int capacityIncrement;
  23.     // Vector的序列版本号
  24.     private static final long serialVersionUID = -2767605614048989439L;
  26.     //指定数组的初始化大小，和增长系数。容量不能小于0
  27.     public Vector(int initialCapacity, int capacityIncrement) {
  28.         super();
  29.         if (initialCapacity < 0)
  30.             throw new IllegalArgumentException("Illegal Capacity: "+
  31.                     initialCapacity);
  32.         this.elementData = new Object[initialCapacity];
  33.         this.capacityIncrement = capacityIncrement;
  34.     }
  36.    //指定容量，增长系数未 0
  37.     public Vector(int initialCapacity) {
  38.         this(initialCapacity, 0);
  39.     }
  41.     //采用默认 容量 10 增长系数为 0
  42.     public Vector() {
  43.         this(10);
  44.     }
  46.     //使用另一个集合构造改集合
  47.     public Vector(Collection<? extends E> c) {
  48.         elementData = c.toArray();
  49.         elementCount = elementData.length;
  50.         // c.toArray可能（错误地）不返回Object []
  51.         if (elementData.getClass() != Object[].class)
  52.             elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
  53.     }
  56.     //这时将Veector中的所有数据都拷贝到anArray中去
  57.     public synchronized void copyInto(Object[] anArray) {
  58.         System.arraycopy(elementData, 0, anArray, 0, elementCount);
  59.     }
  61.     //缩小当前数组的容量，为当前数组中元素的个数
  62.     public synchronized void trimToSize() {
  63.         modCount++;
  64.         int oldCapacity = elementData.length;
  65.         if (elementCount < oldCapacity) {
  66.             //使用Arrays.copyOf方法将数据中的元素copy到新数组中
  67.             elementData = Arrays.copyOf(elementData, elementCount);
  68.         }
  69.     }
  72.     //如有必要，增加当前数组的容量，以确保至少可以保存minCapacity容量参数指定的元素个数
  73.     public synchronized void ensureCapacity(int minCapacity) {
  74.         if (minCapacity > 0) {
  75.             modCount++;
  76.             ensureCapacityHelper(minCapacity);
  77.         }
  78.     }
  81.     /**
  82.      * 和上面方法的功能一样，这么做的原因是这是一个内部使用的方法，使用就没有必要去同步，这样的好处就是可用
  83.      * 降低同步所带来的开销
  84.      */
  85.     private void ensureCapacityHelper(int minCapacity) {
  86.         if (minCapacity - elementData.length > 0)
  87.             grow(minCapacity);
  88.     }
  90.     //当前数组的最大容量，其实扩容可用扩容到 Integer.MAX_VALUE往下面看就知道了
  91.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  93.     //Vectory的扩容方法，嗯嗯看看它的扩容机制吧
  94.     private void grow(int minCapacity) {
  95.         int oldCapacity = elementData.length;
  96.         //新的数组长度 = 旧数组长度 + 增长系数大于0加增长系数 否则 + 旧数组长度
  97.         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
  98.                 capacityIncrement : oldCapacity);
  99.         //如果计算后还不够就 = 最小扩容数
  100.         if (newCapacity - minCapacity < 0)
  101.             newCapacity = minCapacity;
  102.         //如果大于最大扩容数
  103.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  104.         /**
  105.          * hugeCapacity 返回 嗯嗯从这我们可用看错最大看扩容量位Integer.MAX_VALUE
  106.          * (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE : MAX_ARRAY_SIZE;
  107.          *
  108.          */
  109.             newCapacity = hugeCapacity(minCapacity);
  110.         elementData = Arrays.copyOf(elementData, newCapacity);
  111.     }
  114.     private static int hugeCapacity(int minCapacity) {
  115.         if (minCapacity < 0) // overflow
  116.             throw new OutOfMemoryError();
  117.         return (minCapacity > MAX_ARRAY_SIZE) ?
  118.                 Integer.MAX_VALUE :
  119.                 MAX_ARRAY_SIZE;
  120.     }
  122.     //设置当前数组的元素个数，如果小于当前元素的个数
  123.     //那么就将多出来的元素置空，如果大于数组扩容
  124.     public synchronized void setSize(int newSize) {
  125.         modCount++;
  126.         if (newSize > elementCount) {
  127.             ensureCapacityHelper(newSize);
  128.         } else {
  129.             for (int i = newSize ; i < elementCount ; i++) {
  130.                 elementData[i] = null;
  131.             }
  132.         }
  133.         elementCount = newSize;
  134.     }
  136.     //当前数组的大小
  137.     public synchronized int capacity() {
  138.         return elementData.length;
  139.     }
  140.     //元素个数
  141.     public synchronized int size() {
  142.         return elementCount;
  143.     }
  145.     //是否为空
  146.     public synchronized boolean isEmpty() {
  147.         return elementCount == 0;
  148.     }
  151.     //返回“Vector中全部元素对应的Enumeration（枚举）
  152.     public Enumeration<E> elements() {
  153.         //通过匿名类实现 Enumeration 接口
  154.         return new Enumeration<E>() {
  155.             int count = 0;
  157.             public boolean hasMoreElements() {
  158.                 return count < elementCount;
  159.             }
  161.             public E nextElement() {
  162.                 synchronized (Vector.this) {
  163.                     if (count < elementCount) {
  164.                         return elementData(count++);
  165.                     }
  166.                 }
  167.                 throw new NoSuchElementException("Vector Enumeration");
  168.             }
  169.         };
  170.     }
  172.     //是否包含指定元素
  173.     public boolean contains(Object o) {
  174.         //从顶一位开始查找 通过 >= 0 判断是否包含
  175.         return indexOf(o, 0) >= 0;
  176.     }
  178.     //返回指定元素在数组中的位置
  179.     public int indexOf(Object o) {
  180.         return indexOf(o, 0);
  181.     }
  183.     //指定元素 开始位置 返回改元素在数组中的下标
  184.     public synchronized int indexOf(Object o, int index) {
  185.         //判断以下是否位空，为空 用 == 不位空用 equals
  186.         if (o == null) {
  187.             //循环查找，找到返回
  188.             for (int i = index ; i < elementCount ; i++)
  189.                 if (elementData[i]==null)
  190.                     return i;
  191.         } else {
  192.             for (int i = index ; i < elementCount ; i++)
  193.                 if (o.equals(elementData[i]))
  194.                     return i;
  195.         }
  196.         //如果每找到返回状态码 -1
  197.         return -1;
  198.     }
  200.    //重后往前找，元素在数组中的位置。重最后一个元素开始找起
  201.     public synchronized int lastIndexOf(Object o) {
  202.         return lastIndexOf(o, elementCount-1);
  203.     }
  205.     //指定查找元素和查找起始位置。从后往前找
  206.     public synchronized int lastIndexOf(Object o, int index) {
  207.         if (index >= elementCount)
  208.             throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
  210.         if (o == null) {
  211.             //就是倒着循环判断
  212.             for (int i = index; i >= 0; i--)
  213.                 if (elementData[i]==null)
  214.                     return i;
  215.         } else {
  216.             for (int i = index; i >= 0; i--)
  217.                 if (o.equals(elementData[i]))
  218.                     return i;
  219.         }
  220.         //找不到一样返回状态码 -1
  221.         return -1;
  222.     }
  224.     //返回指定下标处的元素
  225.     public synchronized E elementAt(int index) {
  226.         if (index >= elementCount) {
  227.             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
  228.         }
  230.         return elementData(index);
  231.     }
  233.     //返回第一个元素
  234.     public synchronized E firstElement() {
  235.         if (elementCount == 0) {
  236.             throw new NoSuchElementException();
  237.         }
  238.         return elementData(0);
  239.     }
  241.     //返回最后一个元素
  242.     public synchronized E lastElement() {
  243.         if (elementCount == 0) {
  244.             throw new NoSuchElementException();
  245.         }
  246.         return elementData(elementCount - 1);
  247.     }
  249.     //修改指定位置的元素
  250.     public synchronized void setElementAt(E obj, int index) {
  251.         if (index >= elementCount) {
  252.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  253.                     elementCount);
  254.         }
  255.         elementData[index] = obj;
  256.     }
  258.     //移除指定位置的元素
  259.     public synchronized void removeElementAt(int index) {
  260.         modCount++;
  261.         if (index >= elementCount) {
  262.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  263.                     elementCount);
  264.         }
  265.         else if (index < 0) {
  266.             throw new ArrayIndexOutOfBoundsException(index);
  267.         }
  268.         //j 是删除元素在数组中的位置
  269.         int j = elementCount - index - 1;
  270.         if (j > 0) {
  271.             //移动数组位置：新数组位置 = 原数组移除元素的后一位都通过copy向前移动一位
  272.             System.arraycopy(elementData, index + 1, elementData, index, j);
  273.         }
  274.         elementCount--;
  275.         //copy会多出来一位，设置位null 让gc做它的工作
  276.         elementData[elementCount] = null; /* to let gc do its work */
  277.     }
  279.     //指定位置插入元素
  280.     public synchronized void insertElementAt(E obj, int index) {
  281.         modCount++;
  282.         if (index > elementCount) {
  283.             throw new ArrayIndexOutOfBoundsException(index
  284.                     + " > " + elementCount);
  285.         }
  286.         //是否需要扩容
  287.         ensureCapacityHelper(elementCount + 1);
  288.         //通过arraycopy方法在插入位置向后移动以为，方便元素插入
  289.         System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
  290.         elementData[index] = obj;
  291.         elementCount++;
  292.     }
  294.     //添加元素
  295.     public synchronized void addElement(E obj) {
  296.         modCount++;
  297.         ensureCapacityHelper(elementCount + 1);
  298.         elementData[elementCount++] = obj;
  299.     }
  301.     //移除元素
  302.     public synchronized boolean removeElement(Object obj) {
  303.         modCount++;
  304.         //通过 indexOf获取在数组中的位置
  305.         int i = indexOf(obj);
  306.         if (i >= 0) {
  307.             removeElementAt(i);
  308.             return true;
  309.         }
  310.         return false;
  311.     }
  313.     //删除当前数组中的所有元素
  314.     public synchronized void removeAllElements() {
  315.         modCount++;
  316.         //让gc做它的工作
  317.         for (int i = 0; i < elementCount; i++)
  318.             elementData[i] = null;
  320.         elementCount = 0;
  321.     }
  323.     //克隆函数
  324.     public synchronized Object clone() {
  325.         try {
  326.             @SuppressWarnings("unchecked")
  327.             Vector<E> v = (Vector<E>) super.clone();
  328.             //将当前Vector的全部元素拷贝到v中
  329.             v.elementData = Arrays.copyOf(elementData, elementCount);
  330.             v.modCount = 0;
  331.             return v;
  332.         } catch (CloneNotSupportedException e) {
  333.             // this shouldn't happen, since we are Cloneable
  334.             throw new InternalError(e);
  335.         }
  336.     }
  338.     //返回存有当前集合所有元素引用的数组
  339.     public synchronized Object[] toArray() {
  340.         return Arrays.copyOf(elementData, elementCount);
  341.     }
  343.     // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
  344.     @SuppressWarnings("unchecked")
  345.     public synchronized <T> T[] toArray(T[] a) {
  346.         //如果a的大小小于当前元素的个数 那么就建立新的数组返回
  347.         //如果a的大小大于或等于当前元素的大小就将元素copy到a数组中去
  348.        if (a.length < elementCount)
  349.             return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
  351.         System.arraycopy(elementData, 0, a, 0, elementCount);
  353.         if (a.length > elementCount)
  354.             a[elementCount] = null;
  356.         return a;
  357.     }
  359.     //返回指定位置的元素 这个是内部使用 不加锁，但加锁的那个方法
  360.     //也是调用此方法。看下面的get方法就指定了
  361.     @SuppressWarnings("unchecked")
  362.     E elementData(int index) {
  363.         return (E) elementData[index];
  364.     }
  366.     //加锁了
  367.     public synchronized E get(int index) {
  368.         if (index >= elementCount)
  369.             throw new ArrayIndexOutOfBoundsException(index);
  371.         return elementData(index);
  372.     }
  375.     //修改指定位置的元素
  376.     public synchronized E set(int index, E element) {
  377.         if (index >= elementCount)
  378.             throw new ArrayIndexOutOfBoundsException(index);
  380.         E oldValue = elementData(index);
  381.         elementData[index] = element;
  382.         return oldValue;
  383.     }
  385.     //添加元素
  386.     public synchronized boolean add(E e) {
  387.         modCount++;
  388.         ensureCapacityHelper(elementCount + 1);
  389.         elementData[elementCount++] = e;
  390.         return true;
  391.     }
  393.     //移除匹配元素
  394.     public boolean remove(Object o) {
  395.         return removeElement(o);
  396.     }
  398.     //指定位置添加元素
  399.     public void add(int index, E element) {
  400.         insertElementAt(element, index);
  401.     }
  403.     //指定位置移除元素 并返回被移除的元素
  404.     public synchronized E remove(int index) {
  405.         modCount++;
  406.         if (index >= elementCount)
  407.             throw new ArrayIndexOutOfBoundsException(index);
  408.         E oldValue = elementData(index);
  410.         int numMoved = elementCount - index - 1;
  411.         if (numMoved > 0)
  412.             System.arraycopy(elementData, index+1, elementData, index,
  413.                     numMoved);
  414.         elementData[--elementCount] = null; // Let gc do its work
  416.         return oldValue;
  417.     }
  419.     //清空集合当前的所有数据
  420.     public void clear() {
  421.         removeAllElements();
  422.     }
  426.     //如果此Vector包含指定Collection中的所有元素，则返回true
  427.     public synchronized boolean containsAll(Collection<?> c) {
  428.         return super.containsAll(c);
  429.     }
  431.     //将指定集合的所有数据都添加进当前集合
  432.     public synchronized boolean addAll(Collection<? extends E> c) {
  433.         modCount++;
  434.         Object[] a = c.toArray();
  435.         int numNew = a.length;
  436.         ensureCapacityHelper(elementCount + numNew);
  437.         System.arraycopy(a, 0, elementData, elementCount, numNew);
  438.         elementCount += numNew;
  439.         return numNew != 0;
  440.     }
  443.     //当前Vectory中包含指定集合中的元素通通移除掉
  444.     public synchronized boolean removeAll(Collection<?> c) {
  445.         return super.removeAll(c);
  446.     }
  449.     //删除“非集合c中的元素”
  450.     public synchronized boolean retainAll(Collection<?> c) {
  451.         return super.retainAll(c);
  452.     }
  454.     // 从index位置开始，将集合c中所有元素添加到Vector中
  455.     public synchronized boolean addAll(int index, Collection<? extends E> c) {
  456.         modCount++;
  457.         if (index < 0 || index > elementCount)
  458.             throw new ArrayIndexOutOfBoundsException(index);
  460.         Object[] a = c.toArray();
  461.         int numNew = a.length;
  462.         ensureCapacityHelper(elementCount + numNew);
  464.         int numMoved = elementCount - index;
  465.         if (numMoved > 0)
  466.             System.arraycopy(elementData, index, elementData, index + numNew,
  467.                     numMoved);
  469.         System.arraycopy(a, 0, elementData, index, numNew);
  470.         elementCount += numNew;
  471.         return numNew != 0;
  472.     }
  474.     //Vector的equals实现，就是调用父类AbstractList的equals方法
  475.     public synchronized boolean equals(Object o) {
  476.         return super.equals(o);
  477.     }
  479.     //hashCode码
  480.     public synchronized int hashCode() {
  481.         return super.hashCode();
  482.     }
  484.     //将当前对象转换位字符串
  485.     public synchronized String toString() {
  486.         return super.toString();
  487.     }
  489.     //获取Vector中fromIndex(包括)到toIndex(不包括)的子集
  490.     public synchronized List<E> subList(int fromIndex, int toIndex) {
  491.         return Collections.synchronizedList(super.subList(fromIndex, toIndex),
  492.                 this);
  493.     }
  495.     //移除Vectory中 fromIndex 到 toIndex位置上的所有元素
  496.     protected synchronized void removeRange(int fromIndex, int toIndex) {
  497.         modCount++;
  498.         int numMoved = elementCount - toIndex;
  499.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  500.                 numMoved);
  502.         // Let gc do its work
  503.         int newElementCount = elementCount - (toIndex-fromIndex);
  504.         while (elementCount != newElementCount)
  505.             elementData[--elementCount] = null;
  506.     }
  508.     //序列化的写入函数
  509.     private void readObject(ObjectInputStream in)
  510.             throws IOException, ClassNotFoundException {
  511.         ObjectInputStream.GetField gfields = in.readFields();
  512.         int count = gfields.get("elementCount", 0);
  513.         Object[] data = (Object[])gfields.get("elementData", null);
  514.         if (count < 0 || data == null || count > data.length) {
  515.             throw new StreamCorruptedException("Inconsistent vector internals");
  516.         }
  517.         elementCount = count;
  518.         elementData = data.clone();
  519.     }
  521.     //序列的
  522.     private void writeObject(java.io.ObjectOutputStream s)
  523.             throws java.io.IOException {
  524.         final java.io.ObjectOutputStream.PutField fields = s.putFields();
  525.         final Object[] data;
  526.         synchronized (this) {
  527.             fields.put("capacityIncrement", capacityIncrement);
  528.             fields.put("elementCount", elementCount);
  529.             data = elementData.clone();
  530.         }
  531.         fields.put("elementData", data);
  532.         s.writeFields();
  533.     }
  535.     ///这是返回ListIterator迭代器的方法，指定迭代的开始位置
  536.     public synchronized ListIterator<E> listIterator(int index) {
  537.         if (index < 0 || index > elementCount)
  538.             throw new IndexOutOfBoundsException("Index: "+index);
  539.         return new ListItr(index);
  540.     }
  542.     //开始位置位 0 定死
  543.     public synchronized ListIterator<E> listIterator() {
  544.         return new ListItr(0);
  545.     }
  547.    //这是返回iterator迭代器
  548.     public synchronized Iterator<E> iterator() {
  549.         return new Itr();
  550.     }
  552.     /**
  553.      * AbstractList.Itr的优化版本 的迭代器实现类
  554.      */
  555.     private class Itr implements Iterator<E> {
  556.         int cursor;       //要返回的下一个元素的索引
  557.         int lastRet = -1; // 返回最后一个元素的索引; -1如果没有，
  558.         int expectedModCount = modCount;
  560.         //是否还有下一位
  561.         public boolean hasNext() {
  562.             return cursor != elementCount;
  563.         }
  565.         //返回下一位
  566.         public E next() {
  567.             synchronized (Vector.this) {
  568.                 checkForComodification();
  569.                 int i = cursor;
  570.                 if (i >= elementCount)
  571.                     throw new NoSuchElementException();
  572.                 cursor = i + 1;
  573.                 return elementData(lastRet = i);
  574.             }
  575.         }
  578.         //移除当前所在光标的元素
  579.         public void remove() {
  580.             if (lastRet == -1)
  581.                 throw new IllegalStateException();
  582.             synchronized (Vector.this) {
  583.                 checkForComodification();
  584.                 Vector.this.remove(lastRet);
  585.                 expectedModCount = modCount;
  586.             }
  587.             cursor = lastRet;
  588.             lastRet = -1;
  589.         }
  591.         //这是jdk 1.8新增加的方法，重当前迭代位置开始 每个元素都执行 action的指定操作
  592.         @Override
  593.         public void forEachRemaining(Consumer<? super E> action) {
  594.             Objects.requireNonNull(action);
  595.             synchronized (Vector.this) {
  596.                 final int size = elementCount;
  597.                 int i = cursor;
  598.                 if (i >= size) {
  599.                     return;
  600.                 }
  601.                 @SuppressWarnings("unchecked")
  602.                 final E[] elementData = (E[]) Vector.this.elementData;
  603.                 if (i >= elementData.length) {
  604.                     throw new ConcurrentModificationException();
  605.                 }
  606.                 //循环执行指定操作
  607.                 while (i != size && modCount == expectedModCount) {
  608.                     action.accept(elementData[i++]);
  609.                 }
  610.                 cursor = i;
  611.                 lastRet = i - 1;
  612.                 checkForComodification();
  613.             }
  614.         }
  616.         final void checkForComodification() {
  617.             if (modCount != expectedModCount)
  618.                 throw new ConcurrentModificationException();
  619.         }
  620.     }
  622.     /**
  623.      * AbstractList.ListItr的优化版本 ListIterator 实现
  624.      */
  625.     final class ListItr extends Itr implements ListIterator<E> {
  626.         //指定当前迭代的下一个位置的构造
  627.         ListItr(int index) {
  628.             super();
  629.             cursor = index;
  630.         }
  632.         //是否还有上一位
  633.         public boolean hasPrevious() {
  634.             return cursor != 0;
  635.         }
  637.         //下一位在数组中的下标
  638.         public int nextIndex() {
  639.             return cursor;
  640.         }
  642.         //上一位在数组中的下标
  643.         public int previousIndex() {
  644.             return cursor - 1;
  645.         }
  647.         //返回上以为，并移动光标
  648.         public E previous() {
  649.             synchronized (Vector.this) {
  650.                 checkForComodification();
  651.                 int i = cursor - 1;
  652.                 if (i < 0)
  653.                     throw new NoSuchElementException();
  654.                 cursor = i;
  655.                 return elementData(lastRet = i);
  656.             }
  657.         }
  660.         //修改当前迭代位置的值
  661.         public void set(E e) {
  662.             if (lastRet == -1)
  663.                 throw new IllegalStateException();
  664.             synchronized (Vector.this) {
  665.                 checkForComodification();
  666.                 Vector.this.set(lastRet, e);
  667.             }
  668.         }
  670.         //在当前迭代位置插入元素
  671.         public void add(E e) {
  672.             int i = cursor;
  673.             synchronized (Vector.this) {
  674.                 checkForComodification();
  675.                 Vector.this.add(i, e);
  676.                 expectedModCount = modCount;
  677.             }
  678.             cursor = i + 1;
  679.             lastRet = -1;
  680.         }
  681.     }
  684.     //遍历执行 action 方法
  685.     @Override
  686.     public synchronized void forEach(Consumer<? super E> action) {
  687.         Objects.requireNonNull(action);
  688.         final int expectedModCount = modCount;
  689.         @SuppressWarnings("unchecked")
  690.         final E[] elementData = (E[]) this.elementData;
  691.         final int elementCount = this.elementCount;
  692.         for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
  693.             action.accept(elementData[i]);
  694.         }
  695.         if (modCount != expectedModCount) {
  696.             throw new ConcurrentModificationException();
  697.         }
  698.     }
  700.     @Override
  701.     @SuppressWarnings("unchecked")
  702.     public synchronized boolean removeIf(Predicate<? super E> filter) {
  703.         Objects.requireNonNull(filter);
  704.         // 找出要删除的元素
  705.         // 在此阶段从筛选器谓词引发的任何异常
  706.         // 将不修改集合
  707.         int removeCount = 0;
  708.         final int size = elementCount;
  709.         final BitSet removeSet = new BitSet(size);
  710.         final int expectedModCount = modCount;
  711.         for (int i=0; modCount == expectedModCount && i < size; i++) {
  712.             @SuppressWarnings("unchecked")
  713.             final E element = (E) elementData[i];
  714.             if (filter.test(element)) {
  715.                 removeSet.set(i);
  716.                 removeCount++;
  717.             }
  718.         }
  719.         if (modCount != expectedModCount) {
  720.             throw new ConcurrentModificationException();
  721.         }
  723.         // 移位幸存元素留在被移除元素留下的空间
  724.         final boolean anyToRemove = removeCount > 0;
  725.         if (anyToRemove) {
  726.             final int newSize = size - removeCount;
  727.             for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
  728.                 i = removeSet.nextClearBit(i);
  729.                 elementData[j] = elementData[i];
  730.             }
  731.             for (int k=newSize; k < size; k++) {
  732.                 elementData[k] = null;  // Let gc do its work
  733.             }
  734.             elementCount = newSize;
  735.             if (modCount != expectedModCount) {
  736.                 throw new ConcurrentModificationException();
  737.             }
  738.             modCount++;
  739.         }
  741.         return anyToRemove;
  742.     }
  744.     @Override
  745.     @SuppressWarnings("unchecked")
  746.     //循环遍历 将执行operator返回的元素替换当前元素
  747.     public synchronized void replaceAll(UnaryOperator<E> operator) {
  748.         Objects.requireNonNull(operator);
  749.         final int expectedModCount = modCount;
  750.         final int size = elementCount;
  751.         for (int i=0; modCount == expectedModCount && i < size; i++) {
  752.             elementData[i] = operator.apply((E) elementData[i]);
  753.         }
  754.         if (modCount != expectedModCount) {
  755.             throw new ConcurrentModificationException();
  756.         }
  757.         modCount++;
  758.     }
  760.     @SuppressWarnings("unchecked")
  761.     @Override
  762.     //这是给当前的数据进行排序的方法 Comparator 定义了排序的规则
  763.     public synchronized void sort(Comparator<? super E> c) {
  764.         final int expectedModCount = modCount;
  765.         Arrays.sort((E[]) elementData, 0, elementCount, c);
  766.         if (modCount != expectedModCount) {
  767.             throw new ConcurrentModificationException();
  768.         }
  769.         modCount++;
  770.     }
  772.    //当前数据中创建Spliterator
  773.     @Override
  774.     public Spliterator<E> spliterator() {
  775.         return new VectorSpliterator<>(this, null, 0, -1, 0);
  776.     }
  778.     //与ArrayList Spliterator类似
  779.     static final class VectorSpliterator<E> implements Spliterator<E> {
  780.         private final Vector<E> list;
  781.         private Object[] array;
  782.         private int index; // 当前指数，在提前/拆分时修改
  783.         private int fence; // -1直到使用;然后是最后一个索引
  784.         private int expectedModCount; //栅栏设置时初始化
  786.         /** 创建覆盖给定范围的新分裂器*/
  787.         VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
  788.                           int expectedModCount) {
  789.             this.list = list;
  790.             this.array = array;
  791.             this.index = origin;
  792.             this.fence = fence;
  793.             this.expectedModCount = expectedModCount;
  794.         }
  796.         private int getFence() { // 首次使用时初始化 返回数组的元素个数
  797.             int hi;
  798.             if ((hi = fence) < 0) {
  799.                 synchronized(list) {
  800.                     array = list.elementData;
  801.                     expectedModCount = list.modCount;
  802.                     //hi就等于 = list.elementCount 元素个数
  803.                     hi = fence = list.elementCount;
  804.                 }
  805.             }
  806.             return hi;
  807.         }
  809.         //重当前对象再分割一个 Spliterator
  810.         public Spliterator<E> trySplit() {
  811.             // hi = list.elementCount                                    
  812.             int hi = getFence(),
  813.                     lo = index,
  814.                     //（lo + hi） / 2
  815.                     mid = (lo + hi) >>> 1;
  816.             //看看是否还能拆分出一个 Spliterator 如果拆分不了返回null
  817.             return (lo >= mid) ? null :
  818.                     new VectorSpliterator<E>(list, array, lo, index = mid,
  819.                             expectedModCount);
  820.         }
  822.         @SuppressWarnings("unchecked")
  823.         //将index + 1位执行 action定义的方法 这是jdk 1.8函数编程所提供出来的
  824.         public boolean tryAdvance(Consumer<? super E> action) {
  825.             int i;
  826.             if (action == null)
  827.                 throw new NullPointerException();
  828.             if (getFence() > (i = index)) {
  829.                 index = i + 1;
  830.                 action.accept((E)array[i]);
  831.                 if (list.modCount != expectedModCount)
  832.                     throw new ConcurrentModificationException();
  833.                 return true;
  834.             }
  835.             return false;
  836.         }
  838.         @SuppressWarnings("unchecked")
  839.         //使用函数式编程 循环数组执行 actioin
  840.         public void forEachRemaining(Consumer<? super E> action) {
  841.             int i, hi; // 提升从循环访问和检查
  842.             Vector<E> lst; 
  843.             Object[] a;
  844.             if (action == null)
  845.                 throw new NullPointerException();
  846.             if ((lst = list) != null) {
  847.                 if ((hi = fence) < 0) {
  848.                     synchronized(lst) {
  849.                         expectedModCount = lst.modCount;
  850.                         a = array = lst.elementData;
  851.                         hi = fence = lst.elementCount;
  852.                     }
  853.                 }
  854.                 else
  855.                     a = array;
  856.                 if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
  857.                     //循环执行
  858.                     while (i < hi)
  859.                         action.accept((E) a[i++]);
  860.                     if (lst.modCount == expectedModCount)
  861.                         return;
  862.                 }
  863.             }
  864.             throw new ConcurrentModificationException();
  865.         }
  868.         //计算当前位置到末尾还有多少个元素
  869.         public long estimateSize() {
  870.             return (long) (getFence() - index);
  871.         }
  874.         public int characteristics() {
  875.             return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
  876.         }
  877.     }
  878. }

结论：

  1. Vector是使用数组保存数据，和ArrayList套路一样。
  2. 如果每有指定构造Vector那么它的默认容量位 10 增长系数位 0。
  3. 扩容机制：如果增长系数不位 0 那么就是当前容量 + 增长系数，否则就的当前容量加一倍，具体还是看看上面的ensureCapacity（）函数，最大扩容量是Integer.MAX_VALUE。
  4. Vector的克隆函数，即是将全部元素克隆到一个数组中。

    遍历方式

    Iterator迭代器 ```java Iterator iterator = vector.iterator();
     while (iterator.hasNext()){
     iterator.next();
    } 或java8的新特性来遍历元素 vector.forEach(a -> {})
**for循环  使用了随机范围的机制**
```java
for (int i = 0; i < vector.size(); i++) {
           vector.get(i);
}

Enumeration遍历

 for (Enumeration enu = vector.elements(); enu.hasMoreElements(); ){
            enu.nextElement();
        }

foreach循环

for (Object o: vector) {
      System.out.println(o);  
}

性能比较

public static void main(String[] args) {
        Vector vec = new Vector();
        for(int i = 0; i < 10000000; i ++)
            vec.add(i);
        iteratorThroughRandomAccess(vec);
        iteratorThroughIterator(vec);
        iteratorThroughJ8(vec);
        iteratorEnumeration(vec);
        iteratorForEach(vec);
    }

public static void iteratorThroughRandomAccess(Vector vector){
    long startTime;
    long endTime;
    startTime = System.currentTimeMillis();
    for (int i = 0; i < vector.size(); i++) {
        vector.get(i);
    }
    endTime = System.currentTimeMillis();
    long interval = endTime - startTime;
    System.out.println("for循环" + interval + "毫秒");
}

public static void iteratorThroughIterator(Vector vector){
    long startTime;
    long endTime;
    startTime = System.currentTimeMillis();
    Iterator iterator = vector.iterator();
    while (iterator.hasNext()){
        iterator.next();
    }
    endTime = System.currentTimeMillis();
    long interval = endTime - startTime;
    System.out.println("迭代器遍历" + interval + "毫秒");
}

public static void iteratorThroughJ8(Vector vector){
    long startTime;
    long endTime;
    startTime = System.currentTimeMillis();
    vector.forEach(a -> {});
    endTime = System.currentTimeMillis();
    long interval = endTime - startTime;
    System.out.println("jdk1.8新特性遍历" + interval + "毫秒");
}

public static void iteratorEnumeration(Vector vector){
    long startTime;
    long endTime;
    startTime = System.currentTimeMillis();
    for (Enumeration enu = vector.elements(); enu.hasMoreElements(); ){
        enu.nextElement();
    }
    endTime = System.currentTimeMillis();
    long interval = endTime - startTime;
    System.out.println("java 枚举遍历历" + interval + "毫秒");
}

public  static void iteratorForEach(Vector vector){
    long startTime;
    long endTime;
    startTime = System.currentTimeMillis();
    for (Object o: vector) ;
    endTime = System.currentTimeMillis();
    long interval = endTime - startTime;
    System.out.println("foreach循环" + interval + "毫秒");

}

执行结果：
使用随机访问遍历479毫秒
迭代器 iterator遍历242毫秒
jdk1.8新特性遍历58毫秒
java 枚举遍历历149毫秒
foreach循环143毫秒