动态数组

最近准备重新温习下数据结构，参考了书上的源码以及ArrayList的一部分源码学习，写的比较简洁

package cn;

import java.util.Arrays;

/**
 * 手动实现一个ArrayList
 * @param <T>
 */
public class SeqList<T> {
    //当前容量
    protected int size;
    //实际存放元素的数组
    protected Object[] elements;
    //默认容量
    private static final int DEFAULT_CAPACITY = 16;

    /**
     * 构造函数这里借鉴了ArrayList的写法用户自己定义容量
     * @param initialCapacity
     */
    public SeqList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elements = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elements = new Object[DEFAULT_CAPACITY];
        } else {
            throw new IllegalArgumentException("The initialCapacity cannot be " + initialCapacity);
        }
    }

    /**
     * 空参构造方法直接设置默认容量
     */
    public SeqList() {
        this.elements = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 判断数组是否为空
     * @return
     */
    public boolean isEmpty() {
        return this.size == 0;
    }

    /**
     * 返回当前数组存放元素数量
     * @return
     */
    public int Size() {
        return this.size;
    }

    /**
     * 根据索引返回元素
     * @param index
     * @return
     */
    public T get(int index) {
        rangeCheck(index);
        return (T) this.elements[index];
    }

    /**
     * 检测数组下标是否越界
     * @param index
     */
    public void rangeCheck(int index) {
        if (index >= this.size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 打印信息
     * @param index
     * @return
     */
    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }

    /**
     * 根据索引修改元素
     * @param index
     * @param element
     * @return
     */
    public T set(int index, T element) {
        rangeCheck(index);
        T oldValue = (T) this.elements[index];
        this.elements[index] = element;
        return oldValue;
    }

    /**
     * 检测是否需要动态扩容
     * @param minCapacity
     */
    public void ensureCapacityInternal(int minCapacity) {
        if (minCapacity == elements.length) {
            int newCapacity = elements.length + (elements.length >> 1);
            elements = Arrays.copyOf(elements, newCapacity);
        }
    }

    /**
     * 添加末尾元素
     * @param element
     * @return
     */
    public boolean add(T element) {
        ensureCapacityInternal(size + 1);
        this.elements[this.size++] = element;
        return true;
    }

    /**
     * 根据索引添加元素
     * @param index
     * @param element
     */
    public void add(int index, T element) {
        rangeCheck(index);
        ensureCapacityInternal(size + 1);
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = element;
        size++;
    }

    /**
     * 根据索引删除元素
     * @param index
     * @return
     */
    public T remove(int index) {
        rangeCheck(index);
        T value = (T) elements[index];
        System.arraycopy(elements, index + 1, elements, index, size - index - 1);
        size--;
        return value;
    }

    /**
     * 根据元素删除元素
     * @param element
     * @return
     */
    public boolean remove(T element) {
        if (element == null) {
            for (int i = 0; i < size; i++) {
                if (elements[i] == null) {
                    remove(i);
                    return true;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (elements[i].equals(element)) {
                    remove(i);
                    return true;
                }

            }
        }
        return false;
    }


    @Override
    public String toString() {
        StringBuffer str = new StringBuffer("{");
        for (int i = 0; i < size; i++) {
            str.append(elements[i] + ",");
        }
        str.append("}");
        return str.toString();
    }
}