目录

简介

介绍

源码分析(基于jdk1.8)

案例（部分api）

简介

      Vector与ArrayList相比，有大部分的方法一样的，不一样的是Vector几乎所有的方法都使用了synchronized修饰，进行了同步，所以Vector是线程安全，可以用于多线程的情况。

      Vector底层也是数组实现的，Vector继承了AbstractList抽象类，实现了List接口，提供了操作队列的方法；实现RandomAccess接口，可以进行随机访问，即通过索引进行访问元素；实现了Cloneable接口，可以进行克隆；实现了java.io.Serializable接口，可以进行序列化，并进行序列化传输。

介绍

1.构造方法

public Vector(int initialCapacity, int capacityIncrement) {}
public Vector(int initialCapacity) {}
public Vector() {}
public Vector(Collection<? extends E> c) {}

• 构造指定初始容量initialCapacity和容量增长系数是capacityIncrement的Vector.
• 构造指定初始容量是initialCapacity，容量增长系数为0的Vector.
• 构造底层数组大小为10，容量增长系数为0的Vector.
• 构建包含了指定集合c的所有元素的Vector.指定集合为null时，将抛出NullPointerException.

2.内部变量

protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;

• elementData—-存储Vector元素的底层数组缓冲,vector的容量是数组缓冲区的长度.
• elementCount—-Vector有效的元素个数.
• capacityIncrement—-容量增长系数，当Vector的元素数超过容量时，自动增长的量.

3.内部方法

源码分析(基于jdk1.8)

关于源码的几点说明：

1）elementData是Vector的底层实现，即数组缓冲，elementCount是有效的元素个数，capacityIncrement是容量增量系数，即向Vector添加元素超过容量时，如果容量增量系数大于0，增加的容量是capacityIncrement，如果容量的增量系数小于等于0，增加的容量是原先容量的1倍。

2）Vector源码大部分的方法使用了synchronzied修饰，保证线程安全。

3）Vector可以存储null值，源码很多地方判断分成了null值和非null值的两种情况。

4）modCount用来记录修改次数，任何对Vector的修改都会modCount++操作。迭代器迭代初始化时会将modCount赋值给 expectedModCount。在迭代过程中，会判断modCount是否等于expectedModCount，如果不等，说明在迭代过程中其他线程修改了Vector，就会抛出ConcurrentModificationException异常。

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   //存储Vector元素的底层数组缓冲
  //vector的容量是数组缓冲区的长度
    protected Object[] elementData;

    //Vector有效的元素个数
    protected int elementCount;

    //容量增长系数，当Vector元素数超过容量时，自动增长的量。
    protected int capacityIncrement;

   //Vector序列化版本号
    private static final long serialVersionUID = -2767605614048989439L;

   
    //构造指定初始容量initialCapacity和容量增长系数是capacityIncrement的Vector
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //构造容量为initialCapacity的对象数组
        this.elementData = new Object[initialCapacity];
        //设置容量增长系数
        this.capacityIncrement = capacityIncrement;
    }

    //构造了指定初始容量是initialCapacity，容量增长系数为0的Vector
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    //构造底层数组大小为10，容量增长系数为0的Vector.
    public Vector() {
        this(10);
    }

    
    //构建包含了指定集合c的所有元素的Vector.指定集合为null时，将抛出NullPointerException.
    public Vector(Collection<? extends E> c) {
      //返回包含集合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中所有的元素拷贝到指定的数组中.
    //1.指定数组anArray是null，将抛出NullPointerException异常.
    //2.指定数组anArray的长度不足以容纳Vector的所有元素，将抛出IndexOutOfBoundsException异常.
    //3.Vector中元素不是指定数组运行时类型(即Vector存储元素类型与数组类型不一致)将抛出ArrayStoreException异常.
    public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

    //缩减Vector的容量到实际元素的个数.
    public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }

    //Vector扩容,如有必要，确保至少能容纳minCapacity个元素
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

    //Vector扩容内部调用的方法，实现了ensureCapacity的非同步的语义
    //Vector内部同步方法可以调用此方法进行扩容，这不需要额外的同步器。
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    //分配数组最大size
  //预留出位置用于保存数组的元信息（指针指向类信息，描述对象类型）
    //https://stackoverflow.com/questions/35756277/why-the-maximum-array-size-of-arraylist-is-integer-max-value-8
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //内部方法调用，扩容到至少为minCapacity
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //当容量增量系数大于0，容量将增加capacityIncrement，即新容量是oldCapacity+capacityIncrement;
        //当容量增量系数小于等于0，容量将增大1倍，新容量是oldCapacity*2.
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        //即扩容后的容量不能小于minCapacity.
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //复制数组，容量为newCapacity
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    //可扩容的最大值
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    //设置Vector的大小;当newSize多于当前元素的个数，多出的位置将会置为null.
    //当newSize小于当前元素的个数，超出newSize的元素将会被丢弃.
    public synchronized void setSize(int newSize) {
        modCount++;
        //newSize大于Vector中实际元素个数，进行扩容
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
          //否则将索引从newSize开始，后面的所有索引位置置为null.
            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中不包含任何元素，将返回true.
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

    //返回Vector中所有元素的Enumeration.用于迭代Vector，
    //Enumeration中的第一项是Vector索引为0的元素，依次往后.
    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,包含指定元素返回true.
    public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }

    //返回Vector中第一次出现指定元素o的索引位置，不包含指定元素将返回-1.
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }

    //从Vector指定位置开始正向搜索，第一次出现指定元素的索引，未找到指定元素将返回-1.
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {
          //如果指定元素为null,正向遍历，返回首次出现null的索引.
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
          //如果指定元素不为null,正向遍历，返回首次出现指定元素的索引.
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        //没找到指定元素返回-1.
        return -1;
    }

    //返回Vector中第后一次出现指定元素o的索引位置，不包含指定元素将返回-1.
    public synchronized int lastIndexOf(Object o) {
        return lastIndexOf(o, elementCount-1);
    }

    //从Vector指定位置开始逆向搜索，最后一次出现指定元素的索引，未找到指定元素将返回-1.
    public synchronized int lastIndexOf(Object o, int index) {
        if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
        //如果指定元素为null,逆向遍历，返回首次出现null的索引
        if (o == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
          //如果指定元素不为null,逆向遍历，返回首次出现指定元素的索引.
            for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
      //没找到指定元素返回-1.
        return -1;
    }

    //返回Vector中指定索引处的元素.
    public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }

   //返回Vector中第一个元素(即索引为0的元素)
    //如果vector不包含任何元素，将抛出NoSuchElementException异常
    public synchronized E firstElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(0);
    }

    //返回Vector中最后一个元素.
    //如果Vector为空，将抛出NoSuchElementException异常.
    public synchronized E lastElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }

    //设置指定索引处的元素为指定的obj,即丢弃原先在指定索引的元素.
    public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        elementData[index] = obj;
    }

    //删除指定索引处的元素.
    public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        //元素个数是elementCount,最后一个元素索引是elementCount-1
        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 */
    }

    //在指定的索引处插入元素obj
    public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        ensureCapacityHelper(elementCount + 1);
        //将index之后的所有元素整体向后移动1位.将指定元素设置到index上.
        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中首次出现的指定元素.
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        //返回指定元素的索引
        int i = indexOf(obj);
        //当索引大于等于0,移除元素，并返回true.
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

    //移除Vector中的所有元素,并将其大小设置0.
    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中所有元素的数组
    //并且返回数组的运行类型是指定的数组类型
    //指定的元素为null,将抛出NullPointerException异常.
    public synchronized <T> T[] toArray(T[] a) {
      //如果数组a的长度小于Vector元素的个数，数组不足与容纳Vector所有的元素.
      //需要创建一个新数组,大小为Vector元素个数.
        if (a.length < elementCount)
            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
        //将Vector中所有元素拷贝到数组a中.
        System.arraycopy(elementData, 0, a, 0, elementCount);
        //如果数组a长度大于vector中元素个数，将多余位置置为null.
        if (a.length > elementCount)
            a[elementCount] = null;
        //返回数组a
        return a;
    }

    // Positional Access Operations
    //***********************索引位置操作*********************//
    
    //返回指定索引的元素.
    E elementData(int index) {
        return (E) elementData[index];
    }

    //返回Vector中指定索引处的元素.
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    //用指定的元素替换Vector中指定索引处的元素
    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中首次出现的指定元素
    public boolean remove(Object o) {
        return removeElement(o);
    }

    //向Vector指定索引处插入指定的元素.
    public void add(int index, E element) {
        insertElementAt(element, index);
    }

    //移除Vector中指定索引处的元素.
    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中所有元素，返回true.
    //如果指定集合为null,将抛出NullPointerException异常.
    public synchronized boolean containsAll(Collection<?> c) {
        return super.containsAll(c);
    }

    //向Vector末尾添加指定集合c中所有的元素.
    //如果指定集合为null,将抛出NullPointerException异常.
    public synchronized boolean addAll(Collection<? extends E> c) {
        modCount++;
        //返回包含集合c中所有元素的数组.
        Object[] a = c.toArray();
        int numNew = a.length;
        //扩容
        ensureCapacityHelper(elementCount + numNew);
        //将数组a中所有元素复制到数组elementData中.
        System.arraycopy(a, 0, elementData, elementCount, numNew);
        elementCount += numNew;
        return numNew != 0;
    }

    //从Vector中移除包含在指定集合c中的所有元素.
    public synchronized boolean removeAll(Collection<?> c) {
        return super.removeAll(c);
    }

    //保留Vector中包含在指定集合c中的所有元素,即移除Vector中所有不包含在指定集合中元素.
    public synchronized boolean retainAll(Collection<?> c) {
        return super.retainAll(c);
    }

    //将指定集合c中所有元素添加到Vector中，位置从指定的index开始。
    //如果指定集合为null,将抛出NullPointerException异常.
    public synchronized boolean addAll(int index, Collection<? extends E> c) {
        modCount++;
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        //返回包含集合c中所有元素的数组.
        Object[] a = c.toArray();
        int numNew = a.length;
        //扩容
        ensureCapacityHelper(elementCount + numNew);
        
        int numMoved = elementCount - index;
        if (numMoved > 0)
          //将elementData中元素整体向后移动numMoved位.
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //然后将数组a中所有元素拷贝到elementData中.
        System.arraycopy(a, 0, elementData, index, numNew);
        elementCount += numNew;
        return numNew != 0;
    }

    //Vector与指定的对象是否相等.
    public synchronized boolean equals(Object o) {
        return super.equals(o);
    }

    //返回Vector的hashCode的值
    public synchronized int hashCode() {
        return super.hashCode();
    }

    //返回Vector的字符串表示
    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;
    }

    //将Vector实例的状态(包含容量增量系数，元素个数以及元素)写到流中(序列化)
    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();
    }

    //返回Vector中指定位置index开始所有元素的迭代器
    public synchronized ListIterator<E> listIterator(int index) {
        if (index < 0 || index > elementCount)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    //返回Vector所有元素的迭代器(以合适的顺序)
    public synchronized ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    //返回Vector所有元素的迭代器(以合适的顺序)
    public synchronized Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * An optimized version of AbstractList.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
      //modCount是用来记录修改次数，任何对Vector的修改都会modCount++操作。
      //迭代器迭代初始化时会将modCount赋值给 expectedModCount。在迭代过程中，会判断modCount是否等于expectedModCount，
      //如果不等，说明在迭代过程中其他线程修改了Vector，就会抛出ConcurrentModificationException异常。
       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();
        }
    }

    /**
     * An optimized version of AbstractList.ListItr
     */
    //内部类，迭代集合的迭代器
    final class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;
        }
        //当反向迭代Vector时,还有可供访问的元素,返回true.
        public boolean hasPrevious() {
            return cursor != 0;
        }
        //返回下次调用next()方法时返回的索引值.
        public int nextIndex() {
            return cursor;
        }
        //返回下次调用previous()方法时返回的索引值.
        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;
        }
    }
    //对Vector中的所有元素执行的指定的action操作
    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();
        }
    }
    
     //移除符合指定条件filter的元素
    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;
    }
     //根据operator操作返回的值替换指定索引处的元素.
    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++;
    }

    //将ArrayList进行排序，会调用Arrays.sort()方法
    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++;
    }
    //......
    //省略了部分代码
}

案例（部分api）

public class VectorDemo2 {
  public static void main(String[] args) {
    testVectorAPI();
  }
  
  private static void testVectorAPI() {
    Vector<String> vector = new Vector<>();
    for(String word:"one two three four five six seven".split(" ")) {
      vector.add(word);
    }
    System.out.println("capacity--------"+vector.capacity());
    System.out.println("size--------"+vector.size());
    //1.通过Enumeration迭代
    printVectorByEnumeration(vector);
    
    String[] words = new String[8];
    //将vector中元素复制到数组中
    vector.copyInto(words);
    System.out.println(Arrays.toString(words));
    
    //大于size的元素，将被丢弃
    vector.setSize(6);
    System.out.println(vector.toString());
    
    //移除指定的元素，jdk1.8提供遍历的方法
    vector.remove("five");
    vector.forEach(v->System.out.print(v+" "));
    System.out.println();
    
    System.out.println("indexOf()-------"+vector.indexOf("one"));
    System.out.println("contains----------"+vector.contains("seven"));
    System.out.println("lastElement()---------"+vector.lastElement());
    System.out.println("firstElement()-----------"+vector.firstElement());
    //2.通过ListIterator进行迭代
    printVectorByListIterator(vector);
    Object[] array = vector.toArray();
    System.out.println(Arrays.toString(array));
    //jdk1.8提供的移除符合条件的元素
    vector.removeIf(v->v.equals("six"));
    //对元素进行排序
    vector.sort((x,y)->x.compareTo(y));
    //3.通过Iterator遍历
    printVectorByIterator(vector);
    //4.可以通过for循环和foreach循环进行遍历
    printVectorByForEach(vector);
    printVectorByFor(vector);
  }
  
  
  private static void printVectorByForEach(Vector<String> vector) {
    for(String str: vector) {
      System.out.print(str+" ");
    }
    System.out.println();
  }

  private static void printVectorByFor(Vector<String> vector) {
    for(int i = 0 ;i< vector.size();i++) {
      System.out.print(vector.get(i)+" ");
    }
    System.out.println();
  }
  private static void printVectorByIterator(Vector<String> vector){
    Iterator<String> iterator = vector.iterator();
    while(iterator.hasNext()) {
      System.out.print(iterator.next()+" ");
    }
    System.out.println();
  }
  
  private static void printVectorByListIterator(Vector<String> vector) {
    ListIterator<String> iterator = vector.listIterator();
    while(iterator.hasNext()) {
      System.out.print(iterator.next()+" ");
    }
    System.out.println();
  }

  private static void printVectorByEnumeration(Vector<String> vector) {
    Enumeration<String> enu = vector.elements();
    while(enu.hasMoreElements()) {
      System.out.print(enu.nextElement()+" ");
    }
    System.out.println();
  }
}

运行结果：

capacity——–10
size——–7
one two three four five six seven 
[one, two, three, four, five, six, seven, null]
[one, two, three, four, five, six]
one two three four six 
indexOf()——-0
contains———-false
lastElement()———six
firstElement()———–one
one two three four six 
[one, two, three, four, six]
four one three two 
four one three two 
four one three two 

关于Vector迭代的几种方法总结：

1）使用Enumeration进行迭代

 Enumeration<String> enu = vector.elements();
 while(enu.hasMoreElements()) {
      System.out.print(enu.nextElement()+" ");
 }

2）使用Iterator迭代器迭代

ListIterator<String> iterator = vector.listIterator();
while(iterator.hasNext()) {
  System.out.print(iterator.next()+" ");
}

3）使用List集合专有的ListIterator迭代器

ListIterator<String> iterator = vector.listIterator();
while(iterator.hasNext()) {
    System.out.print(iterator.next()+" ");
}

4）使用for循环遍历

for(int i = 0 ;i< vector.size();i++) {
    System.out.print(vector.get(i)+" ");
}

5）使用foreach遍历

for(String str: vector) {
   System.out.print(str);
}