Java小白集合源碼的學習系列：Vector

目錄

• Vector源碼學習
  • Vector繼承體系
  • Vector核心源碼
    • 基本屬性
    • 構造器
    • 擴容機制
  • Enumeration
    • 概述
    • 源碼描述
    • 具體操做
  • Vector總結

Vector源碼學習

前文傳送門：
Java小白集合源碼的學習系列：LinkedList
Java小白集合源碼的學習系列：ArrayList
Vector是JDK1.0中的集合，是集合中的老大哥，其中大部分的方法都被synchronized關鍵字所修飾，與ArrayList和LinkedList不一樣，它是線程安全的（關於線程安全，以後學習再作系統總結）。可是隨着一系列的更新迭代，它的缺點漸漸暴露：如方法名字太長，實現接口時出現了許多重複多餘的方法等等。
從JDK1.2開始，Vector類被改進以實現List接口，讓它成爲Java集合框架的一員，若是不須要線程安全，建議使用ArrayList，效率更高。

Vector繼承體系

仍是按照慣例，先看看它的繼承圖，固然這張圖是基於JDK1.8的。

• 能夠看出來它和ArrayList同樣，繼承了AbstractList，實現List接口。
• 實現了RandomAccess接口，支持隨機訪問。
• 實現了Cloneable接口，實現了克隆的功能。
• 實現了Serializable接口，支持序列化。

Vector核心源碼

基本屬性

//存儲元素的數組
    protected Object[] elementData;
    //元素個數
    protected int elementCount;

    //該值決定了增加機制的不一樣
    protected int capacityIncrement;
    private static final long serialVersionUID = -2767605614048989439L;

構造器

咱們能夠得出結論：Vector的底層也是基於數組實現的，可是這些屬性和咱們以前提到的ArrayList有什麼不一樣之處呢？咱們繼續向下看它所提供的幾個構造器：

//兩個參數，建立initialCapacity大小的數組，併爲capacityIncrement賦值
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    //帶一個參數，調用public Vector(int initialCapacity, int capacityIncrement)
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    //無參構造器，調用Vector(int initialCapacity)
    public Vector() {
        this(10);
    }

    //傳入集合
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        //類型判斷
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

咱們能夠發現：

• initialCapacity表明的是數組的容量，咱們能夠指定容量，不指定默認爲10。
• capacityIncrement從字面上看，就能夠知道它表明的是容量增量，意味着這個值將會影響以後的擴容，能夠指定，不指定默認爲0。

擴容機制

那麼咱們繼續來看看它的擴容機制，是否能夠驗證咱們的說法：
基本上的部分，都是和ArrayList相似，咱們直接截取有差別的部分：

private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //若是增量大於0,新容量 = 原容量 + 增量
        //若是增量不大於0，新容量 = 原容量*2
        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);
    }

其餘的部分就不作分析了，以前講的很詳細，能夠看看前面的文章。咱們須要關注的是：

• 若是指定增量（增量>0)，那麼每次在擴容的時候，新容量就是在原容量的基礎上加上指定增量。
• 若是沒有指定增量，那麼每次在擴容的時候，新容量默認變成原容量的兩倍。

Enumeration

概述

提及迭代器，咱們老是第一個想到的就是Iterator，而再Iterator是在JDK1.2的時候誕生的，用於取代JDK1.0版本的惟一迭代器Enumeration。官方對它的解釋是這樣的：

An object that implements the Enumeration interface generates a series of elements, one at a time. Successive calls to the nextElement method return successive elements of the series.

我用拙劣的英語試着翻譯一下：實現Enumeration這個接口的對象呢，將會生成一系列的元素，生成的時候是一個一個生成的，經過調用nextElement這個方法，就能夠返回這個系列裏全部的連續元素。

今天咱們勵志作個光榮的官方文檔搬運工！

Methods are provided to enumerate through the elements of a vector, the keys of a hashtable, and the values in a hashtable. Enumerations are also used to specify the input streams to a SequenceInputStream.

這段的意思也很明白：Enumeration接口爲Vector的元素，hashtable的鍵和值提供了枚舉的方法，它也被運用到指定SequenceInputStream的輸入流中。咱們暫時只須要知道，Vector類中，有一種方法可以產生Eumeration對象就完事了。其餘的咱們後面會進行總結。

接下來這段話至關關鍵！官方文檔中用了大寫的NOTE:

NOTE:The functionality of this interface is duplicated by the Iterator interface. In addition, Iterator adds an optional remove operation, and has shorter method names. New implementations should consider using Iterator in preference to Enumeration.

大體的意思就是：如今這個方法呢，不太適應潮流了，那個年代用起來挺不錯，如今須要年輕一輩來代替了。這個新一代的產物就是Iterator，它複製了Enumeration的功能，而且增長可選的remove操做，並且提供了更簡短的命名。官方彷彿在嬉皮笑臉對你說：親，這邊建議你迭代器儘可能用Iterator喲。

可是儘管如此，咱們還需須要瞭解如下它的基本操做，畢竟之後可能仍是會見到。

源碼描述

//Enumeration接口  
public interface Enumeration<E> {
    //判斷是否還有更多的元素
    boolean hasMoreElements();
    //沒有下一個元素就報錯，有就返回
    E nextElement();
}
//Vector中的elements方法對接口的實現
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<String> v = new Vector<>();
    v.add("天");
    v.add("喬");
    v.add("巴");
    v.add("夏");
    //利用vector對象產生迭代器對象
    Enumeration<String> e = v.elements();
    //判斷後邊是否還有元素
    while(e.hasMoreElements()){
        //挪動指針指向下一個元素
        System.out.print(e.nextElement()+" ");
    }
    //天 喬 巴 夏

Vector總結

• 底層基於數組，能夠實現動態擴增，支持根據索引快速訪問。
• 若是沒有指定容量，默認爲10。若是沒有指定增量，默認爲0。
• 擴容時，若是增量>0，則新容量=指定增量+原容量；若是增量<=0，則新容量爲原容量的兩倍。（注意，Vector裏也有實現肯定容量的方法ensureCapacity）
• 線程安全，如在建立迭代器以後的任什麼時候間對結構進行修改，除了迭代器自己的remove和add外，都會拋出ConcurrentModification異常。因此，Vector經過synchronized關鍵字實現線程同步。能夠參考：https://blog.csdn.net/yjclsx/article/details/85283169

本文如有敘述不當之處，還望各位評論區加以批評指正，謝謝。

參考資料：JDK1.8官方文檔