Java順序表(動態陣列)的手動實現

阿新 • • 發佈：2021-02-11

技術標籤：Java總結

一、動態陣列簡介

普通陣列的侷限性
一般我們運用的普通陣列是固定大小的，長度在定義時就已經決定，後期不可更改。不可超出範圍儲存資料。

int[] a = new int[10];

2.動態陣列
動態陣列是指在宣告時沒有確定陣列大小的陣列，後期可根據需要改變長度。除此之外，還需要配備一些基本功能:

新增元素
刪除元素
(按索引或值)查詢元素

此外，這裡實現的動態陣列需要可以裝入各種型別的元素，我們需要用到泛型

泛型
在宣告某些類時，可以用T(隨便一個字母)代表任意型別。這裡的型別不能是基本型別(int,double等)，而是引用型別(類、陣列、包裝類等)。就相當於一個類模板，用<>表示。比如給T指派一個Integer型別，那這個類中所有T型別都是Integer型別。比如:

public class Test<T> {
    T a;
    Test(T data) {
        a = data;
        System.out.println(a instanceof Integer);
        System.out.println(a instanceof String);
    }
    public static void main(String[] args) {
        new Test<Integer>(100);
    }
}

輸出結果為:
在這裡插入圖片描述
二、動態陣列的基本實現:

基本屬性
這個類中包含length表示當前陣列的容量，size表明當前陣列的大小，那如何宣告陣列呢?這個陣列要能包含所有的型別，想到Object類是所有類的父類，所以宣告一個Object[]的陣列，當元素存進去時，元素型別會自動轉型成Object類。
初始化:
利用構造方法來初始化。無參的方法用來初始化預設長度(10)大小的陣列，含參的方法利用引數值來確定初始化大小

//構造方法
    public ArrayList() {
        length = 10;
        arr = new Object[length];
        size = 0;

    }

    public ArrayList(int length) {
        this.length = length;
        arr = new Object[length];
        size = 0;
    }

新增元素
在新增前需要判斷陣列是否滿，滿了需要擴容。擴容時，宣告一個新長度大小的陣列，把原陣列資料逐個複製到新陣列上，再將原陣列的引用指向新陣列即可。

    public void add(T element) {
        //先判斷是否滿了
        if (size >= arr.length) {
            length *= 1.5;
            Object[] newarr = new Object[length]; 
            for (int i = 0; i < size; i++) {
                newarr[i] = arr[i];
            }
            arr = newarr;
        }
        arr[size++] = element;
    }

刪除元素
這裡過載了兩種方法。一種是按值刪除，一種是按索引刪除。刪除後，需要吧後面的元素往前移動。

 public void delete(T element) {
        int i = 0;
        for (i = 0; i < size; i++) {
            if (element == arr[i]) {
                while (i < size - 1)
                    arr[i] = arr[i + 1];
                size--;
            }
        }
    }

    public void delete(int theIndex) {//索引從0開始
        for (int i = theIndex; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        size--;
    }

查詢元素
這裡也過載了兩種方法。

 public Object find(int theIndex) {     //按索引查詢
        return arr[theIndex];
    }

    public int[] find(T element,int index[]) {         //按元素查詢,返回下標陣列
        int j = 0;
        for (int i = 0; i < size; i++) {
            if (arr[i] == element) {
                index[j++] = i;
            }
        }
        return index;
    }

替換元素
也是兩種替換方法過載

   public void change(T oldElement, T newElement) { //把所有的舊的資料換成新的
        for (int i = 0; i < size; i++) {
            if (arr[i] == oldElement) {
                arr[i] = newElement;
            }
        }
    }

    public void change(int theIndex, T newElement) { //某一索引元素換成新的
        arr[theIndex] = newElement;
    }

數組合並
建立兩個陣列容量之和的新陣列，把第一個數組合第二個陣列值先後逐個複製上去。

 public void mergeList(ArrayList<T> L) {          //二表合併
        int newLength = this.length + L.length;
        int newSize = this.size + L.size;
        Object[] newarr = new Object[newLength];
        for (int i = 0; i < size; i++) {
            newarr[i] = arr[i];
        }
        this.arr = newarr;
        for (int j = 0; j < L.size; j++) {
            this.arr[this.size + j] = L.arr[j];
            System.out.println(this.size);
        }
        this.size = newSize;
        this.length = newLength;
    }

完整類如下:

public class ArrayList<T> {
    int size;
    int length;
    Object[] arr;

    //構造方法
    public ArrayList() {
        length = 10;
        arr = new Object[length];
        size = 0;

    }

    public ArrayList(int length) {
        this.length = length;
        arr = new Object[length];
        size = 0;
    }

    //新增元素
    public void add(T element) {
        //先判斷是否滿了
        if (size >= arr.length) {
            length *= 1.5;
            Object[] newarr = new Object[length]; 
            for (int i = 0; i < size; i++) {
                newarr[i] = arr[i];
            }
            arr = newarr;
        }
        arr[size++] = element;
    }

    public void delete(T element) {
        int i = 0;
        for (i = 0; i < size; i++) {
            if (element == arr[i]) {
                while (i < size - 1)
                    arr[i] = arr[i + 1];
                size--;
            }
        }
    }

    public void delete(int theIndex) {//索引從0開始
        for (int i = theIndex; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        size--;
    }

    public Object find(int theIndex) {     //按索引查詢
        return arr[theIndex];
    }

    public int[] find(T element,int index[]) {         //按元素查詢,返回下標陣列
        int j = 0;
        for (int i = 0; i < size; i++) {
            if (arr[i] == element) {
                index[j++] = i;
            }
        }
        return index;
    }

    public void change(T oldElement, T newElement) { //把所有的舊的資料換成新的
        for (int i = 0; i < size; i++) {
            if (arr[i] == oldElement) {
                arr[i] = newElement;
            }
        }
    }

    public void change(int theIndex, T newElement) { //某一索引元素換成新的
        arr[theIndex] = newElement;
    }

    public void mergeList(ArrayList<T> L) {          //二表合併
        int newLength = this.length + L.length;
        int newSize = this.size + L.size;
        Object[] newarr = new Object[newLength];
        for (int i = 0; i < size; i++) {
            newarr[i] = arr[i];
        }
        this.arr = newarr;
        for (int j = 0; j < L.size; j++) {
            this.arr[this.size + j] = L.arr[j];
            System.out.println(this.size);
        }
        this.size = newSize;
        this.length = newLength;
    }

    public void print() {
        for (int i = 0; i < size; i++) {
            System.out.print(this.arr[i] + " ");
        }
        System.out.println();
    }
}