【java版数据结构】看完数据结构的顺序结构后，紧接着去实现ArrayList的底层（150行代码，数组扩容，增删改查，但未实现迭代器）

实现效果：

需求分析：

可以看到ArrayList容器有很多功能，在指定位置添加元素，在容器末尾添加元素，获取指定位置的元素，获取容器的大小，清空容器的元素，判断容器是否是空的，删除指定位置的元素，删除某一元素等等
现要求同学们把容器的主要功能用数组实现

思维：我们都知道，数组是不可变的，一个数组在被创建的时候，其长度就已经固定住了，不能再改变，但是我们想要往数组里面不断的添加元素，实现ArrayList的效果，这时候我们可以用到数组扩容的思维，其主要思想是，新建一个比当前数组大的数组，将旧数组的元素全部复制到新数组中，新数组中多出来的空位就可添加元素，最后用新数组覆盖旧数组（简而言之，借助了一个较大数组，实现了扩容）具体实例可看下方代码

换言之，我们要实现删除功能，只要创建一个比当前数组小的新数组，再有选择的复制除删除元素之外的其他元素 到新数组中，最后用新数组替换旧数组

//需求：
// 在长度为6的数组[1,2,3,4,5,6]后加上[7，8，9]
// 变成[1,2,3,4,5,6,7,8,9]
//    Arrays.toString(<?>[])方法打印数组内容
public class ArrayExpand {
    public static void main(String[] args) {
        int [] array=new int[6];
        //赋值
        for (int i=0;i<array.length;i++) {
             array[i]=i+1;
        }
        System.out.println("array:"+Arrays.toString(array));
        int [] des=new int[]{7,8,9};
        //数组扩容3个长度
        System.out.println("des:"+Arrays.toString(des));
        int [] newArray=new int [array.length+des.length];
        //旧数组赋值到新数组
        for (int i = 0; i <array.length ; i++) {
            newArray[i]=array[i];
        }
        //要连接的数组赋值到新数组
        for (int i = 0; i <des.length; i++) {
            newArray[array.length+i]=des[i];
        }
        //新数组替换旧数组
        array=newArray;
        //在java中数组也是一个类，每个类都有toString函数
        System.out.println("array:"+Arrays.toString(array));
    }
}

功能图:

功能实现代码:

package 线性结构.数组;

import java.util.Arrays;

/**
 * @ProjectName 数据结构
 * @ClassName Array
 * @Description //面向对象的数组,实现增删改查(ArrayList底层实现)
 * @Email 2992794262@qq.com
 * @Author ASUS
 * @Date 2021/11/11
 **/
public class Array {
    private static Object [] array;

    //构造方法，初始化数组
    public Array() {
        array=new Object[0];
    }

    //返回数组长度
    public  int size(){
        return  array.length;
    }

    //显示数组
    public void show(){
        System.out.println(Arrays.toString(array));
    }

    //在数组最后增加元素
    public void add(Object element){
        Object [] newArray=new Object[array.length+1];
        //旧数组复制到新数组
        for (int i = 0; i <array.length ; i++) {
            newArray[i]=array[i];
        }
        newArray[newArray.length-1]=element;
        //新数组替换旧数组
        array=newArray;
    }

    //在指定位置插入元素
    public  void add(int index,Object element){
        //创建一个新的数组
        Object newArray[]=new Object[array.length+1];
        //将原数组中的元素放入新数组中
        for (int i = 0; i < newArray.length; i++) {
            if(index<0 ||index > array.length-1){
                throw  new RuntimeException("下标越界");
            }else{
                //在插入位置之前
                if (i<index){
                    newArray[i]=array[i];
                }
                //在插入位置之后
                else if(i>index){
                    newArray[i]=array[i-1];
                }
                else{
                    newArray[i]=element;
                }
            }
        }
        //新数组替换旧数组s
        array=newArray;
    }

    //删除数组的最后一个元素
    public static void delete(){
        //创建一个新的数组
        Object[]newArray=new Object[array.length-1];
        //将原数组除最后一个元素之外的其他元素放入新数组中
        for (int i = 0; i <array.length-1 ; i++) {
            newArray[i]=array[i];
        }
        //新数组替换旧数组
        array=newArray;
    }

    //删除某个位置的元素
    public void delete(int index){
        Object [] newArray=new Object[array.length-1];
        for (int i = 0; i <newArray.length ; i++) {
            if(index<0 ||index > array.length-1){
                throw  new RuntimeException("下标越界");
            }else{
            //在指定位置之前
            if(i<index){
                newArray[i]=array[i];
            }
            //在指定位置之后
            else{
                newArray[i]=array[i+1];
            }
            }
        }
        //新数组替换旧数组
        array=newArray;
    }

    //替换指定位置
    public void set(int index,Object element){
        array[index]=element;
    }

    //查询指定位置的元素
    public Object get(int index){
        return array[index];
    }

    //线性查找算法实现indexOf底层，返回参数第一次出现的位置
    public int indexOf(Object element){
        //没找到返回-1
        int index=-1;
        for (int i = 0; i <array.length; i++) {
            if (array[i].equals(element)){
                index= i;
                break;
            }
        }
        return  index;
    }

    //清空数组功能
    public void clear(){
         Array a=new Array();
         //把当前的对象的属性数组变成当前对象
         a.array=array;
        for (int i = 0; i <array.length ; i++) {
            a.delete();
        }
    }

    //判空功能
    public boolean isEmpty(){
        if (array.length==0){
            return true;
        }
        else
            return false;
    }
}

测试类：

package 线性结构.数组;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @ProjectName 数据结构
 * @ClassName TestArray
 * @Description //
 * @Email 2992794262@qq.com
 * @Author ASUS
 * @Date 2021/11/11
 **/
public class TestArray {
    public static void main(String[] args) {
        Array array=new Array();

        while(true){
            System.out.println("1.查看数组大小\t2.判断数组是否为空\t\t3.打印数组元素\t4.清空数组");
            System.out.println("5.在末尾添加元素\t6.在指定位置添加元素\t7.删除末尾元素\t8.删除指定位置元素");
            System.out.println("9.替换指定位置元素\t10.查询指定位置元素\t11.获取指定元素第一次出现的下标\t12.退出");
            Scanner input=new Scanner(System.in);
            int n=input.nextInt();
            switch(n){
                case 1:
                    System.out.println("size = "+array.size());
                    break;
                case 2:
                    System.out.println("数组是空的 : "+array.isEmpty());
                    break;
                case 3:
                    array.show();break;
                case 4:
                    array.clear();
                    System.out.println("数组已清空");
                    break;
                case 5:
                    System.out.print("请输入你要添加的元素: ");
                    Object element=input.next();
                    array.add(element);
                    System.out.println("添加成功");
                    break;
                case 6:
                    System.out.print("请输入你要添加的位置: ");
                    int index=input.nextInt();
                    System.out.print("请输入你要添加的元素: ");
                    Object object=input.next();
                    array.add(index,object);
                    System.out.println("添加成功");break;
                case 7:
                    array.delete();
                    System.out.println("删除成功");
                    break;
                case 8:
                    System.out.print("请输入你要删除元素的指定位置: ");
                    int i=input.nextInt();
                    array.delete(i);
                    System.out.println("删除成功");break;
                case 9:
                    System.out.print("请输入你要替换的元素的下标: ");
                    int j=input.nextInt();
                    System.out.print("请输入你要替换的新元素: ");
                    Object object1=input.next();
                    array.set(j,object1);
                    System.out.println("替换成功");
                    break;
                case 10:
                    System.out.print("请输入你要查询的元素的下标: ");
                    int k=input.nextInt();
                    System.out.println("查询结果："+array.get(k));
                    break;
                case 11:
                    System.out.print("请输入你要查询的元素: ");
                    Object object2=input.next();
                    int first=array.indexOf(object2);
                    System.out.println("第一次出现的位置是："+first);
                    break;
                default:System.exit(0);
            }
        }

    }
}