创建一个自己的数组
首先明确我们的数组都有什么功能

功能：
1.插入：向索引位置插入一个元素，后面的元素往后平移，由此还可以引申出头部添加元素，尾部添加元素两个功能
2.删除：删除某个索引的元素，并把后面的元素整体前移，由此还可以引申出删除头部元素，删除尾部元素
3.获取：获取数组实际长度，获取数组容量，获取数组索引对应的值，获取由值对应的索引
4.判断：判断数组是否为空，判断是否含有某个元素
5.修改：修改索引位置的值
6.toString：重写toString方法，把数组中的元素转换成String类型便于显示出
7.resize():重新为数组设置容积
为什么要重新设置容积呢？是为了处理当数组已满或者数组有太多空闲容量的情况。当数组已满时，由于我们不知道用户还要添加多少个数组，把容积设置成+1，+n都不合适，所以我们要给他添加到原先容积的2倍。当数组删除元素后有太多空闲容量时，我们需要让数组容积变成原先的1/4，因为如果变成1/2的话，万一用户刚删除完一个又添加一个元素，然后又删除一个又添加一个元素的话，这样子就需要一会变一下容积一会变一下容积，这样子变容积很繁琐，所以变成原先的1/4更合适点。
泛型：
我们的数组不仅是能存放int类型，当传参传入什么类型时，就应该保存什么类型，所以我们需要用到泛型

public class MyArrary<T> {
    private T[] value;    //保存数据
    int size;   //实际存放个数
    int capacity;   //容积

    //  构造方法
    public MyArrary(int capacity){
        if(capacity<=0){
            this.capacity=10;
        }else {
            this.capacity=capacity;
        }
        this.size=0;
        this.value=(T[])(new Object[this.capacity]);
        //不可以直接new一个T[]类型，所以需要先new一个Object[]类型然后转为T[]
    }

    //获取实际长度
    public int getSize() {
        return this.size;
    }

    //获取数组的容积
    public int getCapacity() {
        return this.capacity;
    }

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

    //向数组中添加元素
    //this.size是指向待插入元素的索引
    public void adddata(T data){
        insert(this.size,data);
    }

    //修改指定位置的值
    public void modify(int index,T data){
        if(index<0||index>capacity){
            throw new IllegalArgumentException("index is invalid.");
        }
        this.value[index]=data;
    }

    //插入元素
    public void insert(int index,T data){
        if(index<0||index>this.capacity){
            throw new IllegalArgumentException("index is invalid.");
        }
        if(this.size==this.capacity){   //如果数组满了就重新设置容积
            resize(2*this.capacity);
        }
        for(int i=this.size;i>index;i--){   //从末尾size开始往回遍历，第i个等于i-1个
            this.value[i]=this.value[i-1];
        }
        this.size++;
        this.value[index]=data;
    }

    //删除索引位置元素
    public void delete(int index){
        if(index<0||index>this.capacity){
            throw new IllegalArgumentException("index is invalid.");
        }
        if(this.size<=this.capacity/4){     //如果数组的实际长度比容积的1/4还小说明浪费了太多空间需要重新设置容积
            resize(this.capacity/2);
        }
        for(int i=index;i<this.size-1;i++){     //从索引开始第i个等于i+1个
            this.value[i]=this.value[i+1];
        }
        this.size--;
    }

    //获取索引位置的值
    public T getindexdata(int index){
        if(index<0||index>this.capacity){
            throw new IllegalArgumentException("index is invalid.");
        }
        return this.value[index];
    }

    //根据值获取索引
    public int getindex(T data){
        for (int i = 0; i < this.size; i++) {
            if(data==this.value[i]){
                return i;
            }
        }
        return -1;
    }

    //向头部添加元素
    public void inserttop(T data){
        insert(0,data);
    }

    @Override
    public String toString() {
        StringBuilder s=new StringBuilder();    //需要用到StringBuilder的append来添加'[',']',','
        s.append("[");
        for (int i = 0; i < this.size; i++) {
            s.append(this.value[i]);
            if(i!=this.size-1) {
                s.append(",");
            }
        }
        s.append("]");
        String string=s.toString();     //把StringBuilder转换成String
        return string;
    }

    //是否包含某元素
    public boolean contain(T data){
        for (int i = 0; i < this.size; i++) {
            if(data==this.value[i]){
                return true;
            }
        }
        return false;
    }

    //重新给容积
    private void resize(int newcapacity){
        //由于数组的容积都是不变的所以需要新建一个数组
        T [] newvalue=(T[])(new Object[newcapacity]);
        //转移数组
        for (int i = 0; i < this.size; i++) {
            newvalue[i]=this.value[i];
        }
        //改变容器，数组
        this.value=newvalue;
        this.capacity=newcapacity;
    }
}