数据结构：数组的实现+增删改查功能

package 数据结构;

import java.util.Arrays;
import java.util.Comparator;

import static java.util.Arrays.*;

public class MyArray<T> {

    private T[] array;
    private int size;
    private int length;

    //默认构造器
    public MyArray() {
        this.length = 2;
        size = 0;
        array = (T[]) new Object[length];

    }

    //自定义数组长度
    public MyArray(int length) {
        this.size = 0;
        this.length = length;
        this.array = (T[]) new Object[length];
    }

    //    数组的有效长度
    public int getsize() {
        return size;
    }

    //    遍历数组的元素
    public void display() {
        for (int i = 0; i < size; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    @Override
    public String toString() {
        return "MyArray{" +
                "array=" + Arrays.toString(array) +
                '}';
    }

    //增加元素
    public boolean add(T value) {
        if (size == length) {
            System.out.println("数组容量不足,需要扩容");
            array = this.grow();
            array[size] = value;

        } else {
            array[size] = value;

        }
        size++;
        return true;
    }
    //扩容2倍的增长方式
    private T[] grow(){
       T[] newarray = (T[]) new Object[2*length];
        System.arraycopy(array,0,newarray,0,length);
        return  newarray;
    }

    //删除元素
    public boolean delect(T value) {
        for (int i = 0; i < size; i++) {
            if (array[i].equals(value)) {
                for (int j = i; j < size; j++) {
                    array[j] = array[j + 1];
                }
                size--;
                return true;
            }
        }
        return false;
    }
    
}
class testArray{
    public static void main(String[] args) {
        MyArray<Integer>  array = new MyArray<Integer>();
        array.add(23);
        array.add(34);
        array.display();
        System.out.println(array.delect(56));
        array.add(67);
        System.out.println(array.getsize());
    }
}

数组的优缺点：

随机查找快，时间复杂度为O（1）；

删除速度慢，如果删除的是中间元素，需要将后面的元素移动，时间复杂度较高

增加元素尾插方法，时间复杂度为O(1);

数组一旦创建，大小固定，必须自己去实现扩容机制，扩容的话，需要一个更大的数组，将旧数组的元素拷贝到新的数组，然后才能添加元素，这意味着内存中必须要有连续的内存空间才可以实现扩容。