关于java:java集合9-Vector接口源码超级详细解析

[TOC]

1.Vector 介绍

Vector和后面说的 ArrayList 很是相似，这里说的也是 1.8 版本，它是一个队列，然而实质上底层也是数组实现的。同样继承 AbstractList，实现了List,RandomAcess,Cloneable, java.io.Serializable 接口。具备以下特点：

• 提供随机拜访的性能：实现 RandomAcess 接口，这个接口次要是为 List 提供快速访问的性能，也就是通过元素的索引，能够快速访问到。
• 可克隆：实现了 Cloneable 接口
• 是一个反对新增，删除，批改，查问，遍历等性能。
• 可序列化和反序列化
• 容量不够，能够触发主动扩容
• * 最大的特点是：线程平安的，相当于线程平安的ArrayList。

定义源码如下：

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}

2. 成员变量

底层是数组，减少元素，数组空间不够的时候，须要扩容。

• elementData：真正保留数据的数组
• elementCount：理论元素个数
• capacityIncrement：容量减少系数，就是扩容的时候减少的容量
• serialVersionUID：序列化 id

    // 真正保留数据的数组
    protected Object[] elementData;

    // 元素个数
    protected int elementCount;

    // 容量减少系数
    protected int capacityIncrement;
    // 序列化 id
    private static final long serialVersionUID = -2767605614048989439L;

3. 构造函数

Vector一共有四个构造函数：

• 指定容量和增长系数
• 指定容量
• 不指定，应用默认容量值 10
• 指定汇合初始化

1. 指定容量和增长系数构造函数

    public Vector(int initialCapacity, int capacityIncrement) {super();
        // 非法判断
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity:"+
                                               initialCapacity);
        // 初始化数组
        this.elementData = new Object[initialCapacity];
        // 指定增长系数
        this.capacityIncrement = capacityIncrement;
    }

2. 指定初始化容量，增长系数默认为 0

    public Vector(int initialCapacity) {this(initialCapacity, 0);
    }

3. 什么都不指定，默认给的容量是 10：

    public Vector() {this(10);
    }

4. 指定汇合初始化：

    public Vector(Collection<? extends E> c) {
        // 转换成为数组
        Object[] a = c.toArray();
        // 大小为数组的大小
        elementCount = a.length;
        // 如果是 ArrayList，则间接复制
        if (c.getClass() == ArrayList.class) {elementData = a;} else {
            // 否则须要进行拷贝
            elementData = Arrays.copyOf(a, elementCount, Object[].class);
        }
    }

4. 罕用办法

4.1 减少

减少元素，默认是在最初增加，如果容量不够的时候会触发扩容机制。

    public synchronized void addElement(E obj) {
        // 批改次数减少
        modCount++;
        // 确保容量足够（如果须要，外面会有扩容，复制操作）ensureCapacityHelper(elementCount + 1);
        // 将新元素放在最初一个元素，个数减少
        elementData[elementCount++] = obj;
    }

那么它是如何确保容量的呢？
能够看到 ensureCapacityHelper() 外面判断减少后的元素个数是否大于当初数组的长度，如果不满足，就须要扩容。调用 grow() 函数扩容。

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    // 扩容，传入的是须要最小的容量
    private void grow(int minCapacity) {
        // overflow-conscious code
        // 以前的容量
        int oldCapacity = elementData.length;
        // 当初的容量，是以前的容量加上扩大系数，如果扩大系数小于等于 0，那么，就是以前的容量的两倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 如果新的容量大于最小须要容量，就满足了
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 如果新的容量比最大的容量还要大（虚拟机的数组大小是有最大值的）if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 须要解决把最大的容量升高一些
            newCapacity = hugeCapacity(minCapacity);
        // 拷贝数据
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

在指定的索引 index，插入数据，实际上调用的是insertElementAt(element, index).

    public void add(int index, E element) {insertElementAt(element, index);
    }
    // 调用插入元素的函数
    public synchronized void insertElementAt(E obj, int index) {
        // 批改次数减少
        modCount++;
        // 判断索引是否非法
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + ">" + elementCount);
        }
        // 确保容量足够
        ensureCapacityHelper(elementCount + 1);
        // 拷贝数据，将前面的元素，往后挪动一位
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        // 将理论的数据插入
        elementData[index] = obj;
        // 个数减少
        elementCount++;
    }    

将一个汇合所有元素增加进去：

    public synchronized boolean addAll(Collection<? extends E> c) {
        // 批改次数减少
        modCount++;
        // 转成数组
        Object[] a = c.toArray();
        // 数组的长度
        int numNew = a.length;
        // 确保容量足够
        ensureCapacityHelper(elementCount + numNew);
        // 拷贝
        System.arraycopy(a, 0, elementData, elementCount, numNew);
        // 更新个数
        elementCount += numNew;
        // 返回增加的数组是不是有数据
        return numNew != 0;
    }

指定 index，插入一个汇合，和后面不一样的中央在于复制之前，须要计算往后面挪动多少位，不是用 for 循环去插入，而是一次性挪动和写入。

    public synchronized boolean addAll(int index, Collection<? extends E> c) {
        // 批改次数减少
        modCount++;
        // 非法判断
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 转换数组
        Object[] a = c.toArray();
        // 插入数组长度
        int numNew = a.length;
        // 确保数组的长度是否非法
        ensureCapacityHelper(elementCount + numNew);
        // 挪动的步长计算
        int numMoved = elementCount - index;
        if (numMoved > 0)
            // 挪动前面的元素，腾出地位给插入的元素
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        // 插入元素
        System.arraycopy(a, 0, elementData, index, numNew);
        // 更新个数
        elementCount += numNew;
        // 插入元素个数是否为 0
        return numNew != 0;
    }

4.2 删除

删除指定元素

    public boolean remove(Object o) {return removeElement(o);
    }

    // 理论调用的是 removeElement()
    public synchronized boolean removeElement(Object obj) {
        // 批改次数减少
        modCount++;
        // 获取第一个满足条件的元素缩影
        int i = indexOf(obj);
        // 索引如果满足条件
        if (i >= 0) {
            // 将索引为 i 的元素从数组中移除
            removeElementAt(i);
            return true;
        }
        return false;
    }
    // 操作数组删除元素
    public synchronized void removeElementAt(int index) {
        // 批改次数减少
        modCount++;
        // 是否非法
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + ">=" +
                                                     elementCount);
        }
        else if (index < 0) {throw new ArrayIndexOutOfBoundsException(index);
        }
        // index 前面的元素个数
        int j = elementCount - index - 1;
        if (j > 0) {
            // 往前面挪动一位（复制，笼罩）System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        // 更新个数
        elementCount--;
        // 原来最初一个元素的地位置空
        elementData[elementCount] = null; /* to let gc do its work */
    }

依照索引删除元素：

    public synchronized E remove(int index) {
        // 批改次数减少
        modCount++;
        // 合法性判断
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 保留原来的数据
        E oldValue = elementData(index);
        // 挪动的个数
        int numMoved = elementCount - index - 1;
        // 如果挪动个数大于 0
        if (numMoved > 0)
            // 前面的元素往前面挪动一位，赋值，笼罩
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 最初一个元素置空
        elementData[--elementCount] = null; // Let gc do its work
        // 返回旧的元素
        return oldValue;
    }

4.3 批改

上面两个 set 函数都是，批改索引为 index 的元素，区别就是一个会返回旧的元素，一个不会返回旧的元素。

    public synchronized E set(int index, E element) {
        // 合法性判断
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 取出旧的元素
        E oldValue = elementData(index);
        // 更新
        elementData[index] = element;
        // 返回旧的元素
        return oldValue;
    }
    public synchronized void setElementAt(E obj, int index) {
        // 非法哦性判断
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + ">=" +
                                                     elementCount);
        }
        // 间接更新
        elementData[index] = obj;
    }

4.4 查问

    public synchronized E get(int index) {
        // 非法判断
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 返回数组的元素
        return elementData(index);
    }

获取第一个元素：

    public synchronized E firstElement() {if (elementCount == 0) {throw new NoSuchElementException();
        }
        return elementData(0);
    }

获取最初一个元素：

    public synchronized E lastElement() {if (elementCount == 0) {throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }
    E elementData(int index) {return (E) elementData[index];
    }

4.5 其余罕用函数

将元素拷贝进数组中：

   public synchronized void copyInto(Object[] anArray) {System.arraycopy(elementData, 0, anArray, 0, elementCount);
   }

手动缩容，其实就是将外面的数组复制到一个更小的数组，更新数组援用即可。

   public synchronized void trimToSize() {
       // 批改次数减少
       modCount++;
       // 获取数组的长度
       int oldCapacity = elementData.length;
       // 数组长度大于实在的容量，阐明有能够缩容的空间
       if (elementCount < oldCapacity) {
           // 复制到新的数组
           elementData = Arrays.copyOf(elementData, elementCount);
       }
   }

保障容量的函数，其实相当于手动扩容，参数是所须要的最小的容量, 外面调用的 ensureCapacityHelper() 在下面 add() 函数解析的时候曾经说过了，不再解析。

   public synchronized void ensureCapacity(int minCapacity) {if (minCapacity > 0) {
           modCount++;
           ensureCapacityHelper(minCapacity);
       }
   }

手动将元素个数设置为 newSize, 分为两种状况，一种是新的 size 比当初的 size 还要大，就是想到那个于指定容量扩容。另外一种是相当于缩容，然而这个缩容比拟非凡，总的容量实际上没有变动，只是将外面多余的元素置为 null。

   public synchronized void setSize(int newSize) {
       modCount++;
       if (newSize > elementCount) {
           // 扩容
           ensureCapacityHelper(newSize);
       } else {for (int i = newSize ; i < elementCount ; i++) {
               // 将超出个数的元素设置为 null
               elementData[i] = null;
           }
       }
       elementCount = newSize;
   }

获取容量：

    public synchronized int capacity() {return elementData.length;}

获取外面实在的元素个数：

    public synchronized int size() {return elementCount;}

容器是不是为空：

    public synchronized boolean isEmpty() {return elementCount == 0;}

返回枚举类型的元素迭代器，这是一个有意思的办法，相当于用枚举包装了以后的元素，Enumeration是一个接口，这个接口有两个办法，一个是hasMoreElements(), 示意是否有下一个元素。一个是nextElement()，获取下一个元素。

    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");
            }
        };
    }

是否蕴含某一个元素, 其实外面是获取对象的索引，如果索引大于等于 0，证实元素在外面，否则元素不在外面。

    public boolean contains(Object o) {return indexOf(o, 0) >= 0;
    }

返回元素的索引, 分为两种状况，一种是元素是 null 的状况，不能应用 equals() 办法，另一种是非 null，能够间接应用 equals() 办法。

    public int indexOf(Object o) {return indexOf(o, 0);
    }
    public synchronized int indexOf(Object o, int index) {if (o == null) {for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

获取元素最初呈现的索引地位, 和后面一个不一样的是，这个须要从最初一个元素往前面查找

    public synchronized int lastIndexOf(Object o) {return lastIndexOf(o, elementCount-1);
    }
    public synchronized int lastIndexOf(Object o, int index) {if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + ">="+ elementCount);

        if (o == null) {for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

拷贝元素, 数组外面的元素其实拷贝的只是援用，如果批改新的 Vector 外面的对象的属性，旧的也会被批改。

    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);
        }
    }

比方：

class Student {

    public  int age;

    public String name;


    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Test {public static void main(String[] args) {Vector<Student> vector1 = new Vector<>();
        vector1.add(new Student(1,"sam"));

        Vector<Student> vector2 = (Vector<Student>) vector1.clone();
        vector2.get(0).name = "change name";
        System.out.println(vector2);
        System.out.println(vector1);
    }

输入后果如下, 能够看出其实两个汇合外面的 Student 还是同一个对象。

[Student{age=1, name='change name', score=0}]
[Student{age=1, name='change name', score=0}]

将元素转换成为数组，原理也是一样，都是浅拷贝，拷贝的都是元素对象的援用。

    public synchronized Object[] toArray() {return Arrays.copyOf(elementData, elementCount);
    }

指定数组类型的拷贝：

    public synchronized <T> T[] toArray(T[] a) {if (a.length < elementCount)
            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

        System.arraycopy(elementData, 0, a, 0, elementCount);

        if (a.length > elementCount)
            a[elementCount] = null;

        return a;
    }

截取出某一段的元素汇合, 调用的是父类的办法

    public synchronized List<E> subList(int fromIndex, int toIndex) {return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                            this);
    }

移除某一段索引的元素, 咱们能够看到首先是将前面的元素往前面挪动，笼罩掉后面的元素，而后将前面的元素坑位赋值为 null。

    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);
        // 前面的坑位赋值为 null
        while (elementCount != newElementCount)
            elementData[--elementCount] = null;
    }

获取指定地位的迭代器：
Vector和 ArrayList 根本差不多，都是定义了三个迭代器：

• Itr: 实现接口Iterator，有简略的性能：判断是否有下一个元素，获取下一个元素，删除，遍历剩下的元素
• ListItr: 继承 Itr，实现ListIterator，在Itr 的根底上有了更加丰盛的性能。
• VectorSpliterator: 能够宰割的迭代器，次要是为了宰割以适应并行处理。和 ArrayList 外面的 ArrayListSpliterator 相似。

    // 返回指定 index 地位的 ListIterator
    public synchronized ListIterator<E> listIterator(int index) {if (index < 0 || index > elementCount)
            throw new IndexOutOfBoundsException("Index:"+index);
        return new ListItr(index);
    }
    // 返回开始地位的 ListIterator
    public synchronized ListIterator<E> listIterator() {return new ListItr(0);
    }
    // 返回 Itr
    public synchronized Iterator<E> iterator() {return new Itr();
    }
    // 返回 VectorSpliterator
    public Spliterator<E> spliterator() {return new VectorSpliterator<>(this, null, 0, -1, 0);
    }

4.6 Lambda 表达式相干的办法

• forEach：遍历解决
• removeIf：依照条件移除元素
• replaceAll：移除元素
• sort：排序

根本都是将行为当成参数传递到函数中进行解决，外面值得一提的是 removeIf()，外面是将过滤器传递进去，在外面咱们能够看到应用了BitSet，这个货色来保留了须要移除的元素的下标，统计实现之后，前面再取出来进行移除操作。那么这个BitSet 是什么呢？？？????????????????

一个 Bitset 类创立一种非凡类型的数组来保留位值。BitSet 中数组大小会随须要减少。这和位向量（vector of bits）比拟相似。
这是一个传统的类，但它在 Java 2 中被齐全从新设计。

这样一看其实就是一个保留位值的类，能够设置为 true，也能够取出来，这样就比拟合乎当初的场景，先遍历一次，把须要移除的元素用 BitSet 标记一下，而后再次遍历的时候，就复制元素，将这些坑位笼罩掉，就能够了。

   @Override
   public synchronized void forEach(Consumer<? super E> action) {Objects.requireNonNull(action);
       final int expectedModCount = modCount;
       @SuppressWarnings("unchecked")
       final E[] elementData = (E[]) this.elementData;
       final int elementCount = this.elementCount;
       for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
           // 对每一个元素进行解决
           action.accept(elementData[i]);
       }
       if (modCount != expectedModCount) {throw new ConcurrentModificationException();
       }
   }

   @Override
   @SuppressWarnings("unchecked")
   public synchronized boolean removeIf(Predicate<? super E> filter) {Objects.requireNonNull(filter);
       // figure out which elements are to be removed
       // any exception thrown from the filter predicate at this stage
       // will leave the collection unmodified
       int removeCount = 0;
       final int size = elementCount;
       // 依照以后的大小创立一个位值保留 BitSet
       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)) {
               // 将指定索引处的位设置为 true。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++) {
               // 返回第一个设置为 false 的位的索引，这产生在指定的起始索引或之后的索引上。i = removeSet.nextClearBit(i);
               // 元素前移操作，笼罩被移除的元素的地位
               elementData[j] = elementData[i];
           }
           // 将前面的元素坑地位为 null
           for (int k=newSize; k < size; k++) {elementData[k] = null;  // Let gc do its work
           }
           elementCount = newSize;
           if (modCount != expectedModCount) {throw new ConcurrentModificationException();
           }
           modCount++;
       }

       return anyToRemove;
   }

   @Override
   @SuppressWarnings("unchecked")
   public synchronized void replaceAll(UnaryOperator<E> operator) {Objects.requireNonNull(operator);
       final int expectedModCount = modCount;
       final int size = elementCount;
       for (int i=0; modCount == expectedModCount && i < size; i++) {
           // operator 是操作，意思是将改操作利用于外面的每一个元素
           elementData[i] = operator.apply((E) elementData[i]);
       }
       if (modCount != expectedModCount) {throw new ConcurrentModificationException();
       }
       modCount++;
   }

   @SuppressWarnings("unchecked")
   @Override
   public synchronized void sort(Comparator<? super E> c) {
       final int expectedModCount = modCount;
       // 底层其实就是调用了数组的排序办法，将比拟器 c 传递进去
       Arrays.sort((E[]) elementData, 0, elementCount, c);
       if (modCount != expectedModCount) {throw new ConcurrentModificationException();
       }
       modCount++;
   }

4.7 如何遍历元素

遍历办法有一下几种：值得一说的是应用迭代器和应用枚举迭代器进行遍历。

        Vector<String> myVector = new Vector<>();
        
        // 第一种
        for(String item:myVector){System.out.println(item);
        }
        // 第二种
        myVector.forEach(item-> System.out.println(item));
        myVector.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {System.out.println(s);
            }
        });
        
        // 第三种
        for(int index = 0;index<myVector.size();index++){System.out.println(myVector.get(index));
        }
        
        // 第四种
        Iterator<String> iterator = myVector.iterator();
        while(iterator.hasNext()){System.out.println((String)iterator.next());
        }
        
        // 第五种
        Enumeration<String> enumeration = myVector.elements();
        while(enumeration.hasMoreElements()){System.out.println(enumeration.nextElement().toString());
        }

5. 序列化和反序列化

其实咱们能够看到它的元素汇合没有用 transient 来润饰, 和 ArrayList 有所不同。

    protected Object[] elementData;

然而它也重写了序列化的 readObject() 和writeObject()两个办法。和 ArrayList 不同的是，序列化的时候将所有的数组外面的元素都序列化了，更加占用空间。
序列化的时候会序列化三个货色：

• capacityIncrement: 扩容增长系数
• elementCount: 元素个数
• elementData: 数组元素

    private void readObject(ObjectInputStream in)
            throws IOException, ClassNotFoundException {ObjectInputStream.GetField gfields = in.readFields();
        int count = gfields.get("elementCount", 0);
        Object[] data = (Object[])gfields.get("elementData", null);
        if (count < 0 || data == null || count > data.length) {throw new StreamCorruptedException("Inconsistent vector internals");
        }
        elementCount = count;
        elementData = data.clone();}
    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();}

6. 迭代器

Vector和 ArrayList 根本差不多，都是定义了三个迭代器：

• Itr: 实现接口Iterator，有简略的性能：判断是否有下一个元素，获取下一个元素，删除，遍历剩下的元素
• ListItr: 继承 Itr，实现ListIterator，在Itr 的根底上有了更加丰盛的性能。
• VectorSpliterator: 能够宰割的迭代器，次要是为了宰割以适应并行处理。和 ArrayList 外面的 ArrayListSpliterator 相似。

6.1 Itr

Itr这是一个比拟高级的迭代器，实现了 Iterator 接口，有判断是否有下一个元素，拜访下一个元素，删除元素的办法以及遍历对每一个元素解决的办法。
外面有两个比拟重要的属性：

• cursor：下一个行将拜访的元素下标
• lastRet：上一个返回的元素下标，初始化为 -1

两个重要的办法：

• next(): 获取下一个元素
• remove(): 移除以后元素，须要在 next()办法调用之后，能力调用，要不会报错。

和 ArrayList 外面定义的根本差不多，除了这外面其实加上同步，因为要做到线程平安。

    private class Itr implements Iterator<E> {
        // 下一个行将返回的元素 index
        int cursor;       
        // 上一个返回的 index，- 1 则示意没有
        int lastRet = -1; 
        int expectedModCount = modCount;

        // 是否还有下一个元素
        public boolean hasNext() {return cursor != elementCount;}

        // 获取下一个返回的元素
        public E next() {
            // 同步
            synchronized (Vector.this) {checkForComodification();
                // 因为 cursor 自身就是下一个元素的下标，所以这个值间接取到，返回就能够，用 i 保留一下
                int i = cursor;
                if (i >= elementCount)
                    throw new NoSuchElementException();
                // 下一个返回的 index 更新
                cursor = i + 1;
                // 返回 i 地位的值，更新 lastRet 地位
                return elementData(lastRet = i);
            }
        }

        // 移除元素
        public void remove() {if (lastRet == -1)
                throw new IllegalStateException();
            // 同步
            synchronized (Vector.this) {checkForComodification();
                // 调用 Vector 的移除办法
                Vector.this.remove(lastet);
                expectedModCount = modCount;
            }
            // 删除了以后的元素，相当于迭代器倒退了一步
            cursor = lastRet;
            // 上次返回的元素下标更新为 -1，因为移除了
            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();}
    }

6.2 ListItr

拓展了 Itr 的性能，多了几个办法。
次要减少的性能有：

• 依据 index 获取该地位的迭代器
• 判断是否有后面的元素
• 获取下一个返回元素的下标
• 获取上一个返回元素的上面
• 获取上一个元素
• 更新元素
• 减少元素

根本和 ArrayList 的也一样，也就批改的办法上加上了 synchronized 关键字进行同步。

    final class ListItr extends Itr implements ListIterator<E> {ListItr(int index) {super();
            cursor = index;
        }
        // 是否有上一个元素
        public boolean hasPrevious() {return cursor != 0;}
        // 下一个元素下标
        public int nextIndex() {return cursor;}
        // 上一个元素下标
        public int previousIndex() {return cursor - 1;}

        // 获取上一个元素
        public E previous() {
            // 同步
            synchronized (Vector.this) {checkForComodification();
                int i = cursor - 1;
                if (i < 0)
                    throw new NoSuchElementException();
                // 倒退了一步，所以 cursor 相当于减 1
                cursor = i;
                // 更新上一个元素 index
                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;
            }
            // 插入元素之后，下一个元素的下标相当加 1，因为它们相当于后移了
            cursor = i + 1;
            lastRet = -1;
        }
    }

6.3 VectorSpliterator

间接看源码，这是一个用来适应多线程并行迭代的迭代器，能够将汇合分成多端，进行解决，每一个线程执行一段，那么就不会互相烦扰，它能够做到线程平安。

对标ArrayListSpliterator, 外面的实现根本一样。

    static final class VectorSpliterator<E> implements Spliterator<E> {
        private final Vector<E> list;
        private Object[] array;
        // 以后地位
        private int index;
        // 完结地位,- 1 示意最初一个元素
        private int fence; // -1 until used; then one past last index
        private int expectedModCount; // initialized when fence set

        /** Create new spliterator covering the given  range */
        VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
                          int expectedModCount) {
            this.list = list;
            this.array = array;
            this.index = origin;
            this.fence = fence;
            this.expectedModCount = expectedModCount;
        }

        private int getFence() { // initialize on first use
            int hi;
            if ((hi = fence) < 0) {synchronized(list) {
                    array = list.elementData;
                    expectedModCount = list.modCount;
                    hi = fence = list.elementCount;
                }
            }
            return hi;
        }
        // 宰割，每调用一次，将原来的迭代器等分为两份，并返回索引靠前的那一个子迭代器。public Spliterator<E> trySplit() {int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
            return (lo >= mid) ? null :
                new VectorSpliterator<E>(list, array, lo, index = mid,
                                         expectedModCount);
        }
        // 返回 true 时，示意可能还有元素未解决
        // 返回 falsa 时，没有残余元素解决了
        @SuppressWarnings("unchecked")
        public boolean tryAdvance(Consumer<? super E> action) {
            int i;
            if (action == null)
                throw new NullPointerException();
            if (getFence() > (i = index)) {
                index = i + 1;
                action.accept((E)array[i]);
                if (list.modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                return true;
            }
            return false;
        }
        // 遍历解决剩下的元素
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> action) {
            int i, hi; // hoist accesses and checks from loop
            Vector<E> lst; Object[] a;
            if (action == null)
                throw new NullPointerException();
            if ((lst = list) != null) {if ((hi = fence) < 0) {synchronized(lst) {
                        expectedModCount = lst.modCount;
                        a = array = lst.elementData;
                        hi = fence = lst.elementCount;
                    }
                }
                else
                    a = array;
                if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {while (i < hi)
                        action.accept((E) a[i++]);
                    if (lst.modCount == expectedModCount)
                        return;
                }
            }
            throw new ConcurrentModificationException();}
        // 估算大小
        public long estimateSize() {return (long) (getFence() - index);
        }
        // 返回特征值
        public int characteristics() {return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;}
    }

几个迭代器，各有各自的性能，咱们按需应用即可????????????

7. 小结一下

Vector的思路和 ArrayList 根本是雷同的，底层是数组保留元素，Vector 默认的容量是 10，有一个增量系数，如果指定，那么每次都会减少一个系数的大小，否则就扩充一倍。

扩容的时候，其实就是数组的复制，其实还是比拟耗时间的，所以，咱们应用的时候应该尽量避免比拟耗费工夫的扩容操作。

和 ArrayList 最大的不同，是它是线程平安的，简直每一个办法都加上了 Synchronize 关键字，所以它的效率绝对也比拟低一点。
ArrayList 如果须要线程平安，能够应用 List list = Collections.synchronizedList(new ArrayList(...)); 这个办法。

【作者简介】：
秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使迟缓，驰而不息。这个世界心愿所有都很快，更快，然而我心愿本人能走好每一步，写好每一篇文章，期待和你们一起交换。

此文章仅代表本人（本菜鸟）学习积攒记录，或者学习笔记，如有侵权，请分割作者核实删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有谬误之处，还望指出，感激不尽~