使用java实现数组底层代码，关键代码位置都有详细的注释说说明

数据底层实现原理

新建一个类，类名为Array

public class Array {
    // 定义一个名称为data的数组
    private int[] data;
    // 表示数组中的元素个数
    private int size;

    // 构建函数
    public Array(int capacity){
        data = new int[capacity];
        size = 0;
    }

    // 无参构造函数
    public Array(){
        this(10);
    }

    //获取数组中的元素个数
    public int getSize(){
        return size;
    }

    //获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    // 返回数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 向所有元素后增加一个元素
    public void addLast(int e){
        add(size,e);
    }

    // 向所有元素前添加一个元素
    public void addFirst(int e){
        add(0,e);
    }

    public void add(int index, int e){
        if(size == data.length){
            throw new IllegalArgumentException("添加失败，数组已满");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("添加位置必须为正数且不能大于数组中元素个数");
        }
        // size 为数组用的元素个数，size - 1 =  数组元素最后一位的下标
        // 当 i （当前下标）  =  index（要插入的位置），就停止循环，
        // 也就意味着index下标位置开始到最后一个元素已经往后移动了一位，这个时候只需要把 e 赋值到index位置，就完成插入
        // 此处循环是为了把所有的元素向后移动一位，
        for(int i = size - 1; i>= index; i--){
            // i 表示循环的次数，最多有可能循环完整个数组，index 表示循环终止条件，当 i = index 时，表示要插入的位置已经找到了
            data[i+1] = data[i];
        }
        data[index] = e;
        // 插入成功后，size，数组中的元素个数增加1
        size++;
        System.out.println(Arrays.toString(data));
    }

    /**
     * 获取index索引位置的元素
     *
     * @param index
     * @return
     */
    int get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Get failed.Require index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素为e
     *
     * @param index
     * @param e
     */
    void set(int index, int e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Set failed.Require index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 查找数据中是否有元素e
     *
     * @param e
     * @return
     */
    public boolean contains(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }


    /**
     * 查找数组中元素e所在的索引，如果不存在则返回索引为-1
     *
     * @param e
     * @return
     */
    public int find(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 从数组中删除index位置的元素，返回删除的元素
     *
     * @param index
     * @return
     */
    public int remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("删除失败，下标不存在");
        }
        int ret = data[index];
        // 循环是为了把要删除元素的下标之后的元素往前移动一位
        // index + 1 = i 是为了找到index后的元素，只需要把后一位赋值给前一位就相当于删除了下标为index的元素
        // i < size, 有可能遍历整个数组，当i = size 时 就不会继续循环
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        return ret;
    }

    /**
     * 从数组中删除index位置的元素，返回删除的元素
     *
     * @return
     */
    public int removeFirst() {
        return remove(0);
    }

    /**
     * 从数组中删除index位置的元素，返回删除的元素
     *
     * @return
     */
    public int removeLast() {
        return remove(size - 1);
    }

    /**
     * 从数组中删除元素e
     * 1. 可以返回boolean  2.重复数组的考量，删除所有的元素e,设计上的考虑，具体需求具体分析
     *
     * @param e
     */
    public void removeElement(int e) {
        // 先找到元素e的下标， 然后删除
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }


    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size=%d , capacity=%d\n", size, data.length));
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(",");
            }
        }
        res.append(']');
        return res.toString();
    }
}

使用main执行代码

public class ArrayTest {

    public static void main(String[] args) {
        // 数组长度20
        Array arr = new Array(20);
        for (int i = 0; i < 10; i++) {
            arr.addLast(i);
        }
        System.out.println(arr);

        arr.add(1, 100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);

        arr.remove(2);
        System.out.println(arr);

        arr.removeElement(4);
        System.out.println(arr);

        arr.removeFirst();
        System.out.println(arr);
    }

}

可以直接运行，希望可以帮助各位理解数据