数据结构--容量可变数组

/**
 *写一个MyArrayList类,实现如下功能:
 *(1)容量可变;(2)在指定位置插入元素;(3)任意添加元素(4)删除指定位置的元素
 *可变数组:
 *优点是查找速度快;
 *缺点是删除和插入效率低
 */
public class MyArrayList<T> {

    // 定义对象数组的引用,便于对数组持有对象的访问
    private Object[] elementData;
    // 记录数组持有的对象的个数
    private int size;
    // 记录数组的长度
    private int capacity;
    // 默认数组的长度
    private int DEFAULT_SIZE = 16;
    /**
     * 初始化
     */
    // 以默认大小创建空的数组
    public MyArrayList(){
        this.elementData = new Object[DEFAULT_SIZE];
        this.capacity = DEFAULT_SIZE;
    }
    // 以一个元素将数组初始化
    public MyArrayList(T e){
        this();
        elementData[0] = e;
        size++;
    }
    // 以指定长度的数组来初始化空数组,并指定第一个元素
    public MyArrayList(int initialSize, T e){
        // 容量判断
        int capacity = 1;
        while (capacity < initialSize){    
        // 将Capacity设置为大于initialSize的最小的2的n次方
            capacity <<= 1;
        }
        this.capacity = capacity;
        elementData = new Object[capacity];
        elementData[0] = e;
        size++;
    }
    
    // 获取数组持有元素的个数
    public int length(){
        return size;
    }
    
    // 获取指定位置的元素
    @SuppressWarnings("unchecked") //注解
    public T get(int i){
        // 参数错误
        if (i < 0 || i > size -1) {
            throw new IndexOutOfBoundsException("数组下标越界");
        }
        return (T) elementData[i];
    }
    
    // 查找线性表中指定元素的索引
    public int index(T e){
        for (int i = 0; i < size; i++){
            if (elementData[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }
    
    // 向数组的指定位置插入一个元素
    public void insert(T e, int index){
        if (index < 0 || index > size -1) {
            throw new IndexOutOfBoundsException("数组下标越界");
        }
        // 首先判断容量够不够插入该元素:如果够,直接插入;
        // 如果不够,先增容,将从原index处的所有元素后移一位,然后将该元素插入index处
        if (size+1 > capacity) {
            capacity = capacity + 1;
            Object[] oldData = elementData;
            elementData = new Object[capacity];
            for (int i = 0; i < index; i++) {
                elementData[i] = oldData[i];
            }
            for (int i = index; i < capacity; i++) {
                elementData[i+1] = oldData[i];
            }
        }
        elementData[index] = e;
        size++;
    }
    
    // 向数组中添加一个元素:默认添加到该数组容器的末尾
    public void add(T element){
        insert(element, size);
    }
    
    // 删除指定位置的元素
    @SuppressWarnings("unchecked")
    public T remove(T element, int index){
        if (index < 0 || index > size -1) {
            throw new IndexOutOfBoundsException("数组下标越界");
        }
        T oldElement = (T)elementData[index];
        elementData[index] = null;
        size = size - 1;
        // 压缩数组
        if (size > 0) {
            Object[] oldData = elementData;
            elementData = new Object[size];
            for (int i = 0; i < index; i++) {
                elementData[i] = oldData[i];
            }
            for (int i = index + 1; i < size + 1; i++) {
                elementData[i-1] = oldData[i];
            }
        }
        return oldElement;        
    }