动态数组（DynamicArray）接口设计

int size()； //元素的数量
​
boolean isEmpty();  //是否为空
​
boolean contains(E element);    //是否包含某个元素
​
void add(E element);    //添加元素
​
E get(int index);   //返回index位置的元素
​
E set(int index, E element);    //设置index位置的元素（替换）
​
void add(int index, E element); //往index位置添加元素
​
E remove(int index);    //删除index位置的元素
​
int indexOf(E element); //查看元素的位置
​
void clear();   //清除所有元素

成员变量

private size；   //容量
​
private elements[] ；    //存放元素的数组
​
private static final int DEFAULT_CAPACITY;  //默认容量
​
private static final int INITCAPACITY；  //初始化容量
​
private static final int ELEMENT_NOT_FOUND; //找不到元素时的返回值

构造器设计

空参

public DynamicArray(){
        this(DEFAULT_CAPACITY);//默认容量10
    }

有参

public DynamicArray(int initcapacity){
        //为避免因容量过小而造成频繁扩容，故容量是否小于默认容量时自动设置为默认容量
        if(initcapacity<DEFAULT_CAPACITY)
            this.capacity = DEFAULT_CAPACITY;
        else
            this.capacity = initcapacity;
        elements = (E[])new Object[capacity];
    }

扩容机制

private void ensureCapacity(int capacity){//即将使用的容量
        int oldCapacity = elements.length;//保存现有容量为旧容量
        if(oldCapacity>=capacity)//容量足够时直接返回
            return;
        int newCapacity = oldCapacity + oldCapacity >> 1;//容量不够时，扩容1.5倍
        E newArray[] = (E[])new Object[newCapacity];//创建一个新数组用来替换旧数组
        for (int i = 0; i < oldCapacity; i++) {
            newArray[i] = elements[i];
        }
        elements = newArray;//将新数组引用赋值给原elements数组
    }

边界检查

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

方法实现

public int size(){
    return size;
}
​
public boolean isEmpty(){
    return size == 0;
}
​
public boolean contains(E element){
    return indexOf(element) != ELEMENT_NOT_FOUND;//ELEMENT_NOTFOUND=-1
}
​
public void add(E element){
    add(size, element);
}
​
public E get(int index){
    ofBound(index);
    return elements[index];
}
​
public E set(int index, E element){
    ofBound(index);
    E oldElement = elements[index];
    elements[index] = element;
    return oldElement;
}
​
public void add(int index, E element){
    ensureCapacity(size+1);
    for (int i = size+1; i > index; i--) {
        elements[i] = elements[i-1];
    }
     elements[index] = element;
     size++;
}
​
public E remove(int index){
    ofBound(index);
    E oldElement = elements[index];
        for (int i = index; i < size; i++) {
            elements[i] = elements[i+1];
        }
        size--;
        return oldElement;
}
​
public int indexOf(E element){
    for(int i = 0; i < size; i++){
        if(element.equals(elements[i]))
            return i;
    }
    return ELEMENT_NOT_FOUND;
}
​
public void clear(){
    return size = 0;
}