簡單理解ArrayList源碼

Java集合框架中ArrayList

1.ArrayList是動態擴容的，每次擴容爲原來長度的1.5倍，並且採用的是懶加載策略，當第一次調用add方法時，數組纔會擴容爲10（默認值）

2.模擬實現

List接口：

public interface List<E> {

    int size();

    void add(E e);

    E get(int index);

    E set(int index, E e);

    boolean remove(int index);

}

自己實現的MyArrayList在構造方法中數組就初始化大小爲10，源碼中在第一次調用add()時大小才擴容爲10(源碼中是在構造方法中數組引用定義好的默認長度爲0的數組)；

public class MyArrayList<E> implements List<E> {

    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elementData;
    private int size;

    public MyArrayList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

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

    @Override
    public void add(E e) {
        ensureCapacity(size + 1);
        elementData[size++] = e;
    }

    @Override
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    @Override
    public E set(int index, E e) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = e;
        return oldValue;
    }

    @Override
    public boolean remove(int index) {
        rangeCheck(index);

        /*for (int i = index + 1; i < size; i++) {
            elementData[i - 1] = elementData[i];
        }*/


        System.arraycopy(elementData,index+1,elementData,index,size-index-1);

        elementData[--size] = null;

        return true;
    }

    //動態擴容
    private void ensureCapacity(int minCap) {
        if (minCap - elementData.length > 0) {
            group(minCap);
        }
    }

    private void group(int minCap) {
        int oldCap = elementData.length;
        int newCap = oldCap + (oldCap >> 1);

        if (newCap - minCap < 0) {
            newCap = minCap;
        }
        if (newCap - (Integer.MAX_VALUE - 8) > 0) {
            throw new IllegalArgumentException("長度超出");
        }

        elementData = Arrays.copyOf(elementData, newCap);

    }

    //檢查下標是否越界
    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException("下標越界");
        }
    }

    //將Object類型的元素轉爲E
    @SuppressWarnings("unchecked")
    private E elementData(int index) {
        return (E) elementData[index];
    }

    @Override
    public String toString() {
        Object[] res = Arrays.copyOf(elementData,size);
        return Arrays.toString(res);
    }
}

測試

public class Test {
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);

        list.add(1);
        list.add(2);
        list.add(3);

        list.add(1);
        list.add(2);
        list.add(3);

        list.add(1);
        list.add(2);
        list.add(3);

        System.out.println(list);//[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
        System.out.println(list.get(0));//1
        System.out.println(list.size());//12
        list.set(10,0);
        System.out.println(list);//[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 0, 3]
        list.remove(11);
        System.out.println(list.size());//11
        System.out.println(list);//[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 0]

    }

}