ArrayBox

//模拟ArrayList的存入删除
public class ArrayBox<T> {
    //使数组的长度不可变
    private static final int DEFAULT_CAPACITY = 10;
    private Object []elementData;//长度一旦确定不能再次发生改变
    //记录数组的有效长度
    private int size = 0;

    public ArrayBox(){
        elementData = new Object[DEFAULT_CAPACITY];
    }
    public ArrayBox(int capacity){
        elementData = new Object[capacity];
    }
    //查看数组是否能装下新存放的数据，如果不能 就进行扩容
    private void ensureCapacityInternal(int minCapacity){
       //如果数据长度大于创建的数组的长度，就进行扩容
        if(minCapacity>elementData.length){
           //扩容方法
            this.grow(minCapacity);
       }
    }
    //扩容方法
    private void grow(int minCapacity){
        int oldArrayLength = elementData.length;
        int newArrayLength = oldArrayLength + (oldArrayLength>>1);//扩容1.5倍
        if(newArrayLength < minCapacity){
            newArrayLength = minCapacity;
        }
        elementData = this.copyOf(elementData,newArrayLength);
    }
    //将旧数组的数据传入新数组,由于数组长度不可变，所以需要创建一个新数组
    private Object[] copyOf(Object [] oldArray,int newArrayLength){
        Object [] newArray = new Object[newArrayLength];
        for (int i=0; i<oldArray.length; i++){
            newArray[i] = oldArray[i];
        }
        return newArray;
    }
    //判断索引是否越界
     private void rangeCheck(int index){
        if(index<0 || index>=size){     //index有效 <= size - 1
            //参考数组的操作  自己定义一个异常(自己创建的类)来说明这个问题
            throw new MyException("Index:"+index+",Size:"+size);
        }
    }
    //---------------------------------
    //添加元素
    public boolean add(int element){
        //确保我自己的属性数组的内部容量
        this.ensureCapacityInternal(size+1);
        //size 是有效元素的个数，所以应该从1开始存储
        elementData[size++] = element;
        return true;
    }
    //获取索引位置的元素
    public T get(int index){
        //检测index范围
        this.rangeCheck(index);
        return (T)elementData[index];
    }
    //删除元素，并可以获得删除的元素
    public T remove(int index){
        //检测index范围
        this.rangeCheck(index);
        T oldValue = (T)elementData[index];
        for(int i=index;i<size-1;i++){
            elementData[i] = elementData[i+1];
        }
        elementData[--size] = null;//末尾元素清空
        return oldValue;
    }
    //获取数组长度
    public int size(){
        return this.size;
    }
}
//自己的异常类
public class MyException extends RuntimeException {
    public MyException(){}
    public MyException(String msg){
        super(msg);
    }
}

摘自：[https://www.cnblogs.com/yyanghang/p/11061662.html]

自己写了一个

public class ArrayBox{
    private static final int DEFAULT_CAPACITY = 10;

    private int[] elementData;
    private int size = 0;


    public ArrayBox(){
        elementData = new int[DEFAULT_CAPACITY];
    }
    public ArrayBox(int capacity){
        elementData = new int[capacity];
    }



    private void ensureCapacityInternal(int minCapacity){
         if(minCapacity - elementData.length >0){
            this.grow(minCapacity);
         }
    }
    private void grow(int minCapacity){
        //获取原数组长度
        int oldCapacity = elementData.length;

       int newCapacity =  oldCapacity + (oldCapacity >> 1);

       if(newCapacity - minCapacity < 0 ){
           newCapacity = minCapacity;
       }

        elementData = this.copyOf(elementData,newCapacity);
    }

    private int[] copyOf(int[] oldArray, int newCapacity){
        int[] newArray = new int[newCapacity];

        for (int i = 0; i < oldArray.length; i++) {
            newArray[i] = oldArray[i];
        }
      return newArray;
    }

    private  void rangeCheck(int index){
        if (index<0 || index >= size){
            throw  new BoxIndexOUtOfBoundsException("Index:" + index + "Size" + size);
        }
    }








    public boolean add(int element){
        this.ensureCapacityInternal(size+1);
        elementData[size++] = element;
        return true;
    }

    public int[] get (int index){
        this.rangeCheck(index);
        return elementData;
    }

    public int remove(int index){
        this.rangeCheck(index);
        int oldValue = elementData[index];
        for (int i = index; i <size -1 ; i++) {
            elementData[i] = elementData[i-1];
        }
        elementData[--size] = 0;
        return oldValue;
    }


    public int size() {
        return size;
    }
}

异常类

public class BoxIndexOUtOfBoundsException extends RuntimeException {
    public BoxIndexOUtOfBoundsException(){

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

}