编写一个ArraryList类（自动改变大小的数组）

🍜自己编写一个ArraryList类

• 添加功能
• 在指定位置添加功能
• 删除指定位置功能
• 自动扩容
• 自动缩容
• 打印数组内容功能
• 测试
• 补充：单例模式(内部类)
• 通过异常优化数组类

---

1、创建一个Arrays类

• 定义数组、长度、计数、构造器初始化

public class Arrays {
    //数组默认长度
    private static int length;
    //定义一个数组
    private Object[] arrays;
    //定义一个计算数组的长度size
    private int size;
    //初始化
    public Arrays(){
        //初始化长度
        length=5;
        //初始化数组
        arrays=new Object[length];

    }
    ……

---

2、添加方法add(String xx)

• 通过事先创建的数组存储数据

//add添加方法
    public void add(Object obj){
        //判断是否需要扩容
        changeArrays(size);//这里是扩容方法，后面
        arrays[size]=obj;
        System.out.println("length:"+length);
        size++;
    }

3、指定位置添加add(String xx,int Index)

• 根据参数，添加即可a[i+1]=a[i]

//add在指定位置增加元素
    public void add(Object obj,int index){
        changeArrays(size+1);
        //进行index位置判断
        if(index<0 || index>size+1){
            System.out.println("插入为非法！！");
        }else{
            //System.out.println("~~~~~~~");
            for (int i = index-1; i < size-1; i++) {
                arrays[i+1]=arrays[i];
            }
            arrays[index-1]=obj;
            //System.out.println(arrays[index-1]);
        }
        size++;
    }

4、删除指定位置元素

• 通过参数，将元素a[i-1]=a[1]即可

 //删除指定位置上的元素
    public void delete(int index){
        smallArray(size);
        System.out.println("length:"+length);
        //进行index位置判断
        if(index<0 || index>size+1){
            System.out.println("删除索引为非法！！");
        }else{
            //System.out.println("~~~~~~~");
            for (int i = index+1; i < size; i++) {
                arrays[i-1]=arrays[i];
            }
        }
        size--;
    }

---

5、自动扩容

• 创建一个新数组进行替换原数组，并将指引指向型数组

 //扩容方法
    public void changeArrays(int size){
        //定义一个新数组
        Object[] newArray=new Object[length*2];
        if(size==arrays.length){//当size==数组的长度
            length=length*2;
            for (int i = 0; i < size; i++) {
                newArray[i]=arrays[i];
            }
            arrays=null;
            arrays=newArray;
        }
    }

6、缩容方法

• 创建新数组替换原数组，并将指引指向新数组

//缩容方法
    public void smallArray(int size){

        if(size==arrays.length/2.0){//当size==数组的长度
            //定义一个新数组
            Object[] newArray=new Object[length/2];
            length=length/2;
            for (int i = 0; i < size; i++) {
                newArray[i]=arrays[i];
            }
            arrays=null;
            arrays=newArray;
        }
    }

7、打印数组内容

• 重写toString()方法

 //打印方法
    @Override
    public String toString(){
        String s="[";
        for (int i = 0; i < size; i++) {
            if(i== size-1){
                s=s+arrays[i];
            }else {
                s=s+arrays[i]+",";
            }
        }
        s=s+"]";
        return s;
    }
    //获取数组的长度
    public int  getSize(){
        return size;
    }

---

测试：

测试：添加，删除，并显示数组的变化

public class Test {
    public static void main(String[] args) {
        Arrays as=new Arrays();//new 一个数组对象
        for (int i = 0; i < 6; i++) {//添加内容（数组默认长度为5）
            as.add("小王");
            System.out.println(as.toString());
            System.out.println(as.getSize());
        }
        for (int i = 0; i < 3; i++) {//删除内容
            as.delete(1);
            System.out.println(as.toString());
            System.out.println(as.getSize());
        }
    }
}

如图,随着元素达到峰值，会自动增加数组的长度，当数组长度降低，数组的长度也自动减少

---

---

单例模式（内部类）

/*
* 单列模式
* */
public class Inner {
    public static void main(String[] args) {
        In a=In.dui();
        In b=In.dui();
        System.out.println(b);
        System.out.println(a);
    }
}

class In{
    private static class xx{
        private static In i=new In();
        //类似于int a=10;
    }
    private In(){

    }
    public static In dui(){
        return xx.i;
    }

}

---

🍜通过异常优化数组类

1、主要添加两个自定义异常类

//异常类优化数组
class ArrayException extends RuntimeException{
    public ArrayException(){

    }
    public ArrayException(String s){
        super(s);
    }
}

2、对插入元素删除元素进行优化(优化后的全部代码)

public class Arrays {
    //数组默认长度
    private static int length;
    //定义一个数组
    private Object[] arrays;
    //定义一个计算数组的长度size
    private int size;

    //初始化
    public Arrays(){
        //初始化长度
        length=2;
        //初始化数组
        arrays=new Object[length];
    }

    //add添加方法
    public void add(Object obj){
        //判断是否需要扩容
        changeArrays(size);
        arrays[size]=obj;
        size++;
    }

    //add在指定位置增加元素
    public void add(Object obj,int index){
        //进行index位置判断
        if(index<0 || index>size+1){
            throw new ArrayException(index+"插入位置为非法值！！");
        }
        System.out.println(size);
        changeArrays(size);
        for (int i = index-1; i < size; i++) {
            arrays[i+1]=arrays[i];
        }
        arrays[index-1]=obj;
        size++;
    }

    //删除指定位置上的元素
    public void delete(int index){
        //System.out.println("length:"+length);
        //进行index位置判断
        if(index<0 || index>=size+1){
            throw new ArrayException(index+"非法指定位置！！！");
        }
        //删除位置没问题进行处理
        --size;
        smallArray(size);
        //System.out.println("~~~~~~~");
        for (int i = index+1; i < size; i++) {
            arrays[i-1]=arrays[i];

            //System.out.println(arrays[index-1]);
        }

    }

    //扩容方法
    private void changeArrays(int size){

        //定义一个新数组
        Object[] newArray=new Object[length*2];
        if(size==arrays.length){//当size==数组的长度
            length=length*2;
            for (int i = 0; i < size; i++) {
                newArray[i]=arrays[i];
            }
            arrays=null;
            arrays=newArray;
        }
    }
    //缩容方法
    private void smallArray(int size){

        if(size==arrays.length/2.0){//当size==数组的长度的一半
            //定义一个新数组
            Object[] newArray=new Object[length/2];
            length=length/2;
            for (int i = 0; i < size; i++) {
                newArray[i]=arrays[i];
            }
            arrays=null;
            arrays=newArray;
        }
    }

    //打印方法
    @Override
    public String toString(){
        String s="[";
        for (int i = 0; i < size; i++) {
            if(i== size-1){
                s=s+arrays[i];
            }else {
                s=s+arrays[i]+",";
            }
        }
        s=s+"]";
        return s;
    }

    //获取数组的元素个数
    public String  getSize(){
        return "size:"+size;
    }
    //获取数组的长度（方便测试）
    public String getLength(){
        return "length:"+Arrays.length;
    }
}

//异常类优化数组
class ArrayException extends RuntimeException{
    public ArrayException(){
    }
    public ArrayException(String s){
        super(s);
    }
}

• 优化了数组插入异常和数组删除异常的处理

---