动态泛型数组

实现动态泛型数组：

package dataStucture2.array;

/**
 * 动态泛型数组
 * 
 * @author 李腾
 *
 * @param <E>
 */
public class MyDynamicArray<E> {

    /*
     * MyArray对象应当含有的成员属性： 
     * 1 应当含有基本的Java静态数组data 
     * 2 应当含有数组元素个数size 
     * 3 应当含有两个构造函数，有参构造之参为capacity，由用户指定，并且初始化的时候个数size为0 
     * 4 无参之构造，默认容量为10，size为0(this调用有参指定) 
     * 5 应当对外提供查询当前元素个数的方法getSize
     * 6 应当对外提供查询当前数组容量的方法getCapacity 
     * 7 应当对外提供查询数组是否为空的方法
     * 
     */
    private E[] data;
    private int size;

    // 有参构造
    public MyDynamicArray(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    // 无参构造
    public MyDynamicArray() {
        // 此处调用的是当前对象的有参构造方法
        this(10);
    }

    // 获取数组元素个数
    public int getSize() {
        return size;
    }

    // 获取数组容量
    public int getCapacity() {
        return data.length;
    }

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

    /*
     * 添加元素： 1 在数组的末尾添加元素，即size的位置,添加之前判断数组是否已满，添加之后维护size的位置 2
     * 在数组的指定位置添加元素，即数组插入，插入之前将要插入的位置后移一位，再插入 3 在数组的起始添加元素
     */
    public void addLast(E e) {

        /*
         * if(size == data.length) throw new
         * IllegalAccessError("addLast failure");
         * 
         * data[size] = e; size ++;
         */

        add(size, e);
    }

    // 在数组起始位置添加元素
    public void addFirst(E e) {

        add(0, e);
    }

    // 在指定位置添加元素
    public void add(int index, E e) {

        if (index < 0 || index > size)
            throw new IllegalArgumentException("valid index! ");

        if (size == data.length)
            resize(2 * data.length);

        // 将插入位置之后的所有元素后移一位
        for (int i = size - 1; i >= index; i--)
            data[i + 1] = data[i];

        data[index] = e;
        size++;
    }

    /*
     * 数组扩容： 新建一个数组容量为原来的两倍，将原来的数组元素赋给新数组，原来数组指向新数组(将新数组赋给原来的数组)
     */
    private void resize(int length) {

        E[] newData = (E[]) new Object[length];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;

    }

    // 查询数组中指定位置的某个元素
    public E get(int index) {

        if (index < 0 || index > size)
            throw new IllegalArgumentException("valid index! ");

        return data[index];
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalAccessError("Get failed . index is illegal ");
        }

        data[index] = e;
    }

    // 查看数组中是否包含元素e
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e)
                return true;
        }

        return false;
    }

    // 查找元素的索引,如果没有找到返回非法索引-1
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    // 根据索引删除并返回元素,删除之后元素向左移，维护size
    public E remove(int index) {

        if (index < 0 || index >= size)
            throw new IllegalAccessError("valid index ! ");

        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;

        if (size == data.length / 2)
            resize(data.length / 2);
        
        return ret;
    }

    // 删除第一个元素
    public E removeFirst() {
        return remove(0);
    }

    // 删除最后一个元素所对应的索引
    public E removeLast() {
        return remove(size - 1);
    }

    // 如果有某个元素，删除元素e,只删除一个
    public boolean removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
            return true;
        }
        return false;
    }

    @Override
    /*
     * 打印数组信息： 使用StringBuilder容器，向其中添加元素 添加'['在数组起始位置，添加']'在数组末尾
     * 如果不是数组最后一个位置，则添加','作为分隔符
     */
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');

        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1)
                res.append(", ");
        }

        res.append(']');
        return res.toString();
    }

}

数组时间复杂度简单分析：