手动实现 ArrayList

1. 定义接口List:

public interface List<E>
{
    int size();

    boolean isEmpty();

    boolean add(E element);

    boolean add(int index, E element);

    boolean remove(Object o);

    E remove(int index);

    E get(int index);
}

2. 实现接口和方法:

import java.io.Serializable;
import java.util.Arrays;

public class ArrayList<E> implements List<E>, Serializable
{
    private static final long serialVersionUID = 7611369807238751178L;

    /**
     * 默认容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] DEFAULT_EMPTY_DATA_ELEMENT = {};

    private static final int MAX_DATA_SIZE = Integer.MAX_VALUE - 8;

    private int size;

    private int modCount;

    private Object[] dataElement;

    public ArrayList()
    {
        dataElement = DEFAULT_EMPTY_DATA_ELEMENT;
        size = 0;
        modCount = 0;
    }

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

    @Override
    public boolean isEmpty()
    {
        return size == 0;
    }

    @Override
    public boolean add(E element)
    {
        checkAndDilatation(size + 1);
        dataElement[size++] = element;
        return true;
    }

    /**
     * 检查数组容量是否足够并扩容
     *
     * @param minCapacity
     */
    private void checkAndDilatation(int minCapacity)
    {
        if (dataElement == DEFAULT_EMPTY_DATA_ELEMENT)
        {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        dilatation(minCapacity);
    }

    /**
     * 数组扩容
     *
     * @param minCapacity
     */
    private void dilatation(int minCapacity)
    {
        modCount++;
        if (minCapacity - dataElement.length > 0)
        {
            grow(minCapacity);
        }
    }

    /**
     * 扩容实现
     *
     * @param minCapacity
     */
    private void grow(int minCapacity)
    {
        int oldCapacity = dataElement.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
        {
            newCapacity = minCapacity;
        }
        if (newCapacity - MAX_DATA_SIZE > 0)
        {
            newCapacity = hugeCapacity(newCapacity);
        }
        dataElement = Arrays.copyOf(dataElement, newCapacity);
    }

    private int hugeCapacity(int newCapacity)
    {
        if (newCapacity < 0)
        {
            throw new OutOfMemoryError();
        }
        return (newCapacity > MAX_DATA_SIZE) ? Integer.MAX_VALUE : MAX_DATA_SIZE;
    }

    @Override
    public boolean add(int index, E element)
    {
        checkIndexValidity(index);

        checkAndDilatation(size + 1);

        System.arraycopy(dataElement, index, dataElement, index + 1, size-index);
        dataElement[index] = element;
        size++;
        return true;
    }

    private void checkIndexValidity(int index)
    {
        if (index < 0 || index >= size)
        {
            throw new IndexOutOfBoundsException("Index: " + index);
        }
    }

    @Override
    public boolean remove(Object o)
    {
        if (o == null)
        {
            for (int i = 0; i < size; i++)
            {
                if (dataElement[i] == null)
                {
                    fastRemove(i);
                    return true;
                }
            }
        }
        else
        {
            for (int i = 0; i < size; i++)
            {
                if (o.equals(dataElement[i]))
                {
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 移除数据
     * @param index
     */
    private void fastRemove(int index)
    {
        checkIndexValidity(index);
        int moveNum = size - index - 1;
        if (moveNum > 0)
        {
            System.arraycopy(dataElement, index, dataElement, index + 1, moveNum);
        }
        modCount++;
        dataElement[--size] = null;
    }

    @Override
    public E remove(int index)
    {
        checkIndexValidity(index);
        E oldValue = dataElement(index);

        int moveNum = size - index - 1;
        if (moveNum > 0)
        {
            System.arraycopy(dataElement, index, dataElement, index + 1, moveNum);
        }
        modCount++;
        dataElement[--size] = null;
        return oldValue;
    }

    @Override
    public E get(int index)
    {
        checkIndexValidity(index);

        return dataElement(index);
    }

    private E dataElement(int index)
    {
        return (E) dataElement[index];
    }
}