數據結構：數組的實現+增刪改查功能

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);

數組一旦創建，大小固定，必須自己去實現擴容機制，擴容的話，需要一個更大的數組，將舊數組的元素拷貝到新的數組，然後才能添加元素，這意味着內存中必須要有連續的內存空間纔可以實現擴容。