动态数组

简单实现java的一个动态数组（集合）

默认容量为10；

增长方式一次1.5倍；

引用类型内存优化；

@SuppressWarnings("ALL")
public class ArrayList<E> {
    //添加一个长度的成员变量
    private int size = 0;
    //所有的元素
    private E[] elements;
    //默认容量数值
    private static final int DEFAULT_ELEMENTS = 10;
    private static final int ELEMENT_NOT_FIND = -1;

    //构造方法 有参数 确定动态数组的初始容量
    public ArrayList(int capaticy) {
        capaticy = (capaticy <= 10) ? DEFAULT_ELEMENTS : capaticy;
        elements = (E[]) new Object[capaticy];
    }

    //构造函数默认容量10的数组
    public ArrayList() {
        this(DEFAULT_ELEMENTS);
    }


    //添加数据
    public void add(E element) {
        add(size, element);
    }

    //插入元素到指定位置
    public void add(int index, E element) {
        size++;
        //判断是否进行扩容
        ensureCapacity(size);

        rangeCheckForAdd(index);
        for (int i = size - 2; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
    }

    //并非线程安全
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity) return;
        //扩容为原来的1.5倍 位运算效率高
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size - 1; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
        //System.out.println("旧容量为"+oldCapacity+"新容量"+elements.length);
    }


    //删除动态数组中所有的元素
    public void clear() {
        //需要把所有的引用对象销毁
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

    //删除单个数据 通过动态数组的下标去操作
    public E remove(int index) {
        rangeCheckForAdd(index);
        E old = elements[index];
        for (int i = index + 1; i < size; i++) {
            elements[i - 1] = elements[i];
        }
        //删除后需要把最后一个引用对象销毁
        elements[--size] = null;
        return old;
    }

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

    //通过下标去修改某一个元素
    public E set(int index, E element) {
        rangeCheckForAdd(index);
        E oldElement = elements[index];
        elements[index] = element;
        return oldElement;
    }

    //通过元素的下标区查找某一个元素
    public E get(int index) {
        rangeCheckForAdd(index);
        return elements[index];
    }

    //查看元素的位置
    public int indexOf(E element) {
        //如果传进来是null
        if (element == null) {
            //查找第一个空值的位置
            for (int i = 0; i < size; i++) {
                if (elements[i] == null) return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                //因为元素可能有空值 为了避免空指针调用方法
                if (element.equals(elements[i])) return i;
            }
        }

        return ELEMENT_NOT_FIND;
    }

    //查看动态数组的长度
    public int size() {
        return size;
    }

    //查看元素是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //查看是否包含某一个元素
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FIND;
    }
    //重写toString方法


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("size=").append(size).append(",[");
        for (int i = 0; i < size; i++) {
            if (i != 0) sb.append(",");
            sb.append(elements[i]);

        }
        sb.append("]");
        return sb.toString();
    }
}