Vector源碼解讀

1.背景

閱讀源碼是提高編程技能的有效方式...

面試中也經常問到源碼相關的問題.....

2.源碼解讀

在解讀Vector時大家可以先解讀ArrayList,因爲這個兩個的邏輯幾乎是一樣的....

ArrayList源碼解讀:https://www.cnblogs.com/newAndHui/p/16101626.html

區別在於

1.Vector的很多方法都是同步的即線程安全的,二ArrayList的很多方法時線程非同步的;

2.Vector擴容默認是原來的1倍,二ArrayList默認是按照原來的1.5倍擴容;

3.Vectory對象創建時默認數組長度爲10,而ArrayList對象創建時是一個空數組,在添加第一個元素是才設置數組長度爲10

閱讀源碼前自己寫一個與Vector功能差不多的對象MyVector,相信你看懂了MyVector,那麼Vector你就自然懂了...

package com.ldp.collection.my;

import java.util.AbstractList;
import java.util.Arrays;
import java.util.List;
import java.util.RandomAccess;

/**
 * @author 姿勢帝-博客園
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 04/05 10:51
 * @description
 */
public class MyVector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -2767605614048989439L;
    protected Object[] elementData; // 存放元素的數組對象
    protected int elementCount; // 存放的元素個數
    protected int capacityIncrement; // 數組擴容時的擴容量,默認爲0,表示安裝原來的1倍擴容,10擴容一次後爲20
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;// 數組的最大容量

    /**
     * 無參數構造方法,默認容量爲10
     */
    public MyVector() {
        this(10);
    }

    /**
     * 自定義容量的構造方法
     */
    public MyVector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     * 自定義容量 和 擴容數的構造方法
     *
     * @param initialCapacity   數組長度
     * @param capacityIncrement 擴容時的增加長度,默認爲0,安裝原來的1倍擴容
     */
    public MyVector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * 線程安全的,所以很多操作方法都是加了 synchronized 關鍵字的
     */
    @Override
    public synchronized boolean add(E e) {
        // 累加修改次數
        modCount++;
        // 確定容量
        ensureCapacityHelper(elementCount + 1);
        // 在原來的元素後面加一個元素
        elementData[elementCount++] = e;
        return true;
    }

    private void ensureCapacityHelper(int minCapacity) {
        // 當最小需要的容量大於數組長度時進行擴容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // 原來的容量
        int oldCapacity = elementData.length;
        // 新的容量,capacityIncrement=0時,newCapacity=oldCapacity+oldCapacity,即按照原來的1倍擴容
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
        // 加一倍後長度還是不夠，則用傳遞過來的數值minCapacity(addAll來說，就是原長度+新集合長度)
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 超出最大值時計算
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 執行擴容
        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;
    }

    @Override
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    @Override
    public synchronized int size() {
        return elementCount;
    }
}

完美!