java实践项目，替换数组的功能

• 我的项目目录文件夹是java学习，里面有三个文件,BoxException(自定义的错误，准备报错),ClassMix(各种数组的构造和操作函数），testmix(中心文件，从这里开始运行);

BoxException

package java学习;
//定义异常
public class BoxException extends RuntimeException {//继承
    public BoxException(){

    }
    public BoxException(String msg)
    {
        super(msg);
    }
}

textmix

package java学习;
import java学习.ClassMix;
public class testmix {
    public static void main(String[] args) {
        ClassMix<Integer> a = new ClassMix<Integer>();
        for (int i=1;i<6;i++)
        {
            a.add(i);
        }
        System.out.println(a.size());
        for (int i=0;i< a.size();i++){
            System.out.print(a.get(i)+" ");
        }
        System.out.println();
        int c = a.remove(2);
        System.out.println("移除元素"+c);
        for (int i=0;i< a.size();i++){
            System.out.print(a.get(i) + " ");
        }
    }
}

ClassMix

package java学习;
//设计一个类，替代数组可以做的事情，数组长度是固定的，长度一旦固定，使用起来不太方便
//描述类
import java学习.BoxException;
public class ClassMix<E> {
    private Object[] elementData ;
    private int size;//记录数组长度
    private static final int DEFAULT_CAPACITY = 10;
    public ClassMix(){
        elementData = new Object[DEFAULT_CAPACITY];
    }
    public ClassMix(int index){
        elementData = new Object[index];
    }
    //数组扩容,需要提供最小容量
    private void grow(int minCapacity){
        //获取旧数组长度
        int oldCapacity = elementData.length;
        //使用一个很好的算法
        //这里提供思路，右移一位是除以2，左移一位是乘以2，以旧数组的1.5倍数扩容
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果按照这个算法扩容后，所需要的空间还是不够
        if (newCapacity - minCapacity < 0){
            newCapacity = minCapacity;
        }
        elementData = this.copyOf(elementData,newCapacity);
    }
    //提供新数组元素，需要提供新数组的长度还需要提供旧数组
    private   Object[] copyOf(Object [] oldArray,int newCapacity){
        //创建一个新数组
        Object[] newArray = new Object[newCapacity];
        //将旧数组的全部移入新数组
        for (int i=0;i<oldArray.length;i++){
            newArray[i] = oldArray[i];
        }
        return newArray;
    }
    //提供数组的最小容量
    private void ensureCapacityInternal(int minCapacity){
        if(minCapacity-elementData.length > 0){
            //扩容
            this.grow(minCapacity);
        }

    }

    public boolean add(E element){//在创建对象时候创建的
        //确保数组的内部容量够用
        this.ensureCapacityInternal(size +1);
        elementData[size++] = element;
        return true;
    }
    //获取位置上的元素
    public E get(int index)
    { //检查index是否合法
        this.rangeCheck(index);
        //如果上面成功那么数组长度合法
        return (E)elementData[index];
    }
    private void rangeCheck(int index){
        if (index<0||index>=size){
            //如果数组长度不符合规定的话，自己定义异常
           throw  new BoxException("index:" + index +"size:"+size);
        }
    }
    //数组删除元素,返回值--删除的元素
    public E remove(int index){
        this.rangeCheck(index);
        E oldValue = (E)elementData[index];
        //数组的底层想直接进行元素的删除不太可能,我们的处理方法是依次向前覆盖
        for (int i=index;i<size-1;i++){
            elementData[i] = elementData[i+1];
        }
        elementData[--size] = null;
        return oldValue;
    }
    public int size(){
        return size;
    }

}