2021-02-04 java手写数组的底层原理

一、数组与链表的区别

（1）数组在堆内存中创建连续的数据结构，因此数组支持快速查找，但是在新增或删除的时候，因为需要在当前数据结构中调整内存结构的分布，因此新增和插入的效率就会相对变慢，（容量有限）

（2）链表在堆内存中，实现了动态的数据结构，他在堆内存中的元素与元素之间是可以不连续，他们之间的联系是靠指针关联，因此在链表中插入或删除元素，只需要调整一下指针指向的位置就行了，不会回牵扯到数据内存位置的改变，因此删除或插入的效率较高，但是查询相对的效率相对就会变慢。（对容量没有限制）

二、基于java的数组底层原理实现

（1）、静态数组

1. 数组的初始化长度
2. 设置数组的长度
3. 判断当前数组的容量是否已满
4. 判断指定位置删除或者新增的元素的下标是否越界
5. 获取当前数组的长度
6. 新增元素
7. 指定位置添加元素
8. 删除元素
9. 指定位置删除元素
10. 根据元素删除数组中相同的元素

public class ArrayOneVo {
    private int[] data;//数据
    private int size;//数组的长度

    //设置数组的长度，初始化当前数组的长度
    public ArrayOneVo(int size) {
        data =new int[size];
        size = 0;
    }
    //无参构造函数，设置默认的数组长度为10
    public ArrayOneVo() {
        this(10);
    }

    //获取数组的元素个数
    public int getSize(){
        return size;
    }
    //获取数组的容量
    public int getData(){
        return data.length;
    }
    //获取数组是否为空
    public boolean getIsEmPty(){
        return size==0;
    }
    //在index的位置添加新元素
    public void add(int index,int e){
        //判断当前数组容量是否已满
        if(getSize()==getData()){
            System.out.println("当前数组容量已满不能继续添加新元素");
        }
        //防止要插入的位置下标越界
        if(index<0 || index>getData()){
            System.out.println("下表越界");
        }
        //从插入位置到数组的最后一个元素，将所有元素往后迁移一位
        for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        //迁移完之后，将要插入位置的数据替换掉
        data[index]=e;
        //然后增加数组的容量的长度
        size++;
    }

    //在数组的头部添加元素
    public void addHeard(int e){
        //判断数据的容量是否已满
        if(getSize()==getData()){
            System.out.println("数组的容量已满，不能继续添加元素");
        }
        //将数组的元素整体向后迁移一位
        for(int i=size-1;i>=0;i--){
            data[i+1]=data[i];
        }
        data[0]=e;
        size++;
    }
    //在数组的尾部添加元素
    public void addFist(int e){
        //判断数据的容量是否已满
        if(getSize()==getData()){
            System.out.println("数组的容量已满，不能继续添加元素");
        }
        add(size,e);
    }
    //根据索引获取元素
    public int getIndex(int index){
        //判断索引的位置是否正确
        if(index<0||index>size){
            System.out.println("下表越界");
        }
        return data[index];
    }
    //根据索引修改元素
    public void alterIndex(int index,int e){
        //判断索引的位置是否正确
        if(index<0||index>size){
            System.out.println("下表越界");
        }
        data[index]=e;
    }
    //查找数组中是否存在某个元素
    public boolean query(int e){
        for(int i=0;i<size;i++){
            if(data[i]==e){
               return true;
            }
        }
        return false;
    }
    //查询元素e所在的索引，如果不存在就返回-1
    public int getIndexByE(int e){
        for(int i=0;i<size;i++){
            if(data[i]==e){
                return i;
            }
        }
        return -1;
    }
    //从数组中删除index位置的元素，并返回删除的元素
    public int remove(int index){
        //判断下标是否越界
        if(index<0||index>size){
            System.out.println("下表越界");
        }
        int datum = data[index];
        for(int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
        data[size-1]=0;
        size--;
        return datum;
    }

    @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();
    }


    public static void main(String[] args) {
        //1、测试插入元素
        //初始化数组的长度
        ArrayOneVo arrayOneVo = new ArrayOneVo(5);
        //添加元素
        arrayOneVo.add(0,1);
        arrayOneVo.add(1,2);
        arrayOneVo.add(2,3);
        arrayOneVo.addFist(8);
//        arrayOneVo.add(4,5);
        arrayOneVo.addHeard(9);
        System.out.println(Arrays.toString(arrayOneVo.data));
//        System.out.println(arrayOneVo.getIndex(4));
//        arrayOneVo.alterIndex(4,10);
//        System.out.println(Arrays.toString(arrayOneVo.data));
//
//        System.out.println(arrayOneVo.query(10));
//        System.out.println(arrayOneVo.getIndexByE(19));

        System.out.println(arrayOneVo.remove(2));
        System.out.println(Arrays.toString(arrayOneVo.data));

        System.out.println(arrayOneVo.toString());


    }
}

（2）、 动态数组

1. 数组的初始化长度
2. 设置数组的长度
3. 判断当前数组的容量是否已满
4. 判断指定位置删除或者新增的元素的下标是否越界
5. 获取当前数组的长度
6. 新增元素
7. 指定位置添加元素
8. 删除元素
9. 指定位置删除元素
10. 根据元素删除数组中相同的元素
11. 数组的扩容
12. 泛型数组

public class ArrayObjectVo<E> {
    private E[] data;
    private int size;

    //自定义数组的长度
    public ArrayObjectVo(int size) {
        data = (E[]) new Object[size];
        size = 0;
    }

    //自定义默认数组长度
    public ArrayObjectVo() {
        this(10);
    }

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

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

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

    //数组添加元素
    public void add(int index,E e){
        //判断是否下标越界
        if(index<0 || index>size){
            System.out.println("下标越界");
        }
        //判断数组容量是否已满,满了就扩容
        if(size==data.length){
            //这里将数组扩容两倍
            resize(2*size-1);
        }
        for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;

    }
    //数组扩容，或者缩减容量
    public void resize(int resizeSize){
        //重新定义一个新的数组
        E[] e = (E[]) new Object[resizeSize];
        //将旧数组放入新数组
        for(int i=0;i<size;i++){
            e[i]=data[i];
        }
        data=e;
    }
    //在所有元素的最后面添加元素
    public void addLast(E e){
        //判断数组的容量是否已满
        if(size==data.length){
            //进行扩容
            resize(2*size-1);
        }
        add(size,e);
    }
    //在所有元素的头部添加元素
    public void addFirst(E e){
        add(0,e);
    }

    //根据索引删除元素
    public E remove(int index) {
        if(index<0||index>size){
            System.out.println("下标越界");
        }
        E datum = data[index];
        for(int i=index;i<size;i++){
            data[i]=data[i+1];
        }
        data[size-1]=null;
        size--;
        //防止复杂度震荡，所以1/4  防止删到最后一位
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return datum;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(", ");
            }
        }
        res.append(']');
        return res.toString();
    }

    public static void main(String[] args) {
        //初始化数组容量
        ArrayObjectVo<String> objectVo = new ArrayObjectVo<>(5);
        objectVo.add(0,"新");
        objectVo.add(1,"年");
        objectVo.add(2,"快");
        objectVo.add(3,"乐");
        objectVo.add(4,"新");
        objectVo.add(5,"年");
        objectVo.add(6,"快");
        objectVo.add(7,"乐");
        objectVo.addLast("哈哈");
        objectVo.addLast("嘻嘻");
        objectVo.addLast("砰砰");
        objectVo.addFirst("喵喵");
        objectVo.remove(2);
        System.out.println(objectVo.toString());
        System.out.println(objectVo.size);
        System.out.println(objectVo.getDataSize());

    }
}