JAVA 实现顺序表的增删改查

1.线性表

线性表是一种最基本的数据结构，它是表示一组相同类型数据的有限序列，可以把它当作数组参考，但他不是数组，线性表是一种表结构，它能够支持数据的插入，删除，更新，查找等。同时数组可以随意存放在数组中的任何位置，而线性表只能依次有序排列，不能出现空隙。

2.顺序表

将数据依次存储在连续的整块物理空间中，这种存储结构叫做顺序存储结构。而已这种方式实现的线性表，叫做顺序表。表中的每一个个体都称之为元素，上一个元素称之为 前驱。下一个元素，称之为 后驱。

我们设计线性表的目标就是进行更好的管理数据。对数组进行封装，从而完成增删改查。

以下是java 以数组为底层 通过抽象类对顺序表增删改查的实现

启动类

public class Main {
    public static void main(String[] args) {
        //自己定义的Arraylist
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        list.add("就你了",0);
        list.add("阿狗",1);
        //删除元素
        list.remove(0);
        //查找
        System.out.println(list.get(0));

        System.out.println("就你了，阿狗");
    }
}

定义抽象类方法 

/**
 * 线性表抽象类
 * @param <E> 存储的元素(Element)类型
 */
public abstract class AbstractList<E> {
    /**
     *获取表的长度
     * @return 顺序表的长度
     */
    public abstract int size();

    /**
     *添加一个元素
     * @param e 元素
     * @param index 要添加的位置（索引）
     */
    public abstract void add(E e,int index);

    /**
     *删除指定的元素
     * @param index 元素的位置
     * @return 删除的元素
     */
    public abstract E remove(int index);

    /**
     *查到指定的元素
     * @param index 元素的位置
     * @return 指定位置的元素
     */
    public abstract E get(int index);
}

实现类 

public class ArrayList<E> extends AbstractList<E> {
    //设置底层数组
    private Object[] arr = new Object[10];
    //初始插入的长度
    private int size = 0;

    @Override
    public int size() {
        return size;
    }

    @Override
    public void add(E e, int index) {
        //判断插入位置是否合法 需要按照顺序插入
        if (index > size) throw new IllegalArgumentException("非法的插入位置");
        //判断是否需要扩容 增加的长度等于原本定义长度 则需扩容
        if (size >= arr.length){
            //定义一个新的数组 将原本数组循环遍历放入新数组
            Object[] arr1 = new Object[arr.length + 10];
            for (int i = 0; i < arr.length; i++)
                arr1[i] = arr[i];
            arr = arr1;
        }
        //定义下标访问变量
        int j = size -1;
        while ( j >= index){
            //每一轮循环往后搬一位 后移后面的元素
            arr[j+1] = arr[j];
            j--;
        }
        //插入
        arr[index] = e;
        size++;
    }

    @Override
    public E remove(int index) {
        //判断删除位置是否合法 抛出异常
        if (index > size - 1) throw new IllegalArgumentException("非法的删除位置");
        int i = index;
        E e = (E) arr[i];
        while (i < size - 1){
            //前移 顺序表不能有空隙
            arr[i] = arr[i+1];
            i++;
        }
        size --;
        return e;

    }

    @Override
    public E get(int index) {
        if (index >= size) throw new IndexOutOfBoundsException("无法访问到下标位置");
        return (E) arr[index];
    }
}

 以数组为底层 简单的实现了插入 删除 查询 

需要明白其中每个+1 -1的意义  先要了解顺序表插入的 后移  以及删除的 前移。