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(...));這個方法。

【做者簡介】：
秦懷，公衆號【秦懷雜貨店】做者，技術之路不在一時，山高水長，縱使緩慢，馳而不息。這個世界但願一切都很快，更快，可是我但願本身能走好每一步，寫好每一篇文章，期待和大家一塊兒交流。

此文章僅表明本身（本菜鳥）學習積累記錄，或者學習筆記，若有侵權，請聯繫做者覈實刪除。人無完人，文章也同樣，文筆稚嫩，在下不才，勿噴，若是有錯誤之處，還望指出，感激涕零~