Java線性表的順序表示及實現(xiàn)

更新時間：2022年07月03日 10:31:03 作者：??世紀(jì)末的架構(gòu)師????

這篇文章主要介紹了Java線性表的順序表示及實現(xiàn)，順序表是在計算機內(nèi)存中以數(shù)組的形式保存的線性表，線性表的順序存儲是指用一組地址連續(xù)的存儲單元依次存儲線性表中的各個元素、使得線性表中在邏輯結(jié)構(gòu)上相鄰的數(shù)據(jù)元素存儲在相鄰的物理存儲單元中

前言

在之前對順序表使用C語言進行了簡單的實現(xiàn)：C語言線性表順序表示及實現(xiàn)

當(dāng)時使用C語言進行實現(xiàn)是因為學(xué)校的教材使用的是C語言來進行實現(xiàn)，在后來的學(xué)習(xí)中，Java成為了我的主語言，使用不同的語言對順序表來進行實現(xiàn)也可以加深我對語言的理解和應(yīng)用。

一、什么是順序表？

順序表是在計算機內(nèi)存中以數(shù)組的形式保存的線性表，線性表的順序存儲是指用一組地址連續(xù)的存儲單元依次存儲線性表中的各個元素、使得線性表中在邏輯結(jié)構(gòu)上相鄰的數(shù)據(jù)元素存儲在相鄰的物理存儲單元中，即通過數(shù)據(jù)元素物理存儲的相鄰關(guān)系來反映數(shù)據(jù)元素之間邏輯上的相鄰關(guān)系，采用順序存儲結(jié)構(gòu)的線性表通常稱為順序表。順序表是將表中的結(jié)點依次存放在計算機內(nèi)存中一組地址連續(xù)的存儲單元中。

二、順序表的實現(xiàn)

在順序表的定義中可以看到，順序表是一組地址連續(xù)的存儲單元，本質(zhì)上是一種增加了一些基本操作功能的數(shù)組

在本文中要實現(xiàn)的功能有：

獲取順序表中的元素個數(shù)
獲取順序表當(dāng)前的容量
順序表是否為空
在指定索引位置添加元素
在順序表末尾添加元素
在順序表頭部添加元素
獲取指定索引位置的元素
獲取順序表第一個元素
獲取順序表最后一個元素
修改指定索引位置的元素
判斷順序表中是否包含指定元素
獲取順序表中指定元素的索引
刪除指定索引位置的元素
刪除并返回順序表第一個元素
刪除并返回順序表最后一個元素
刪除順序表中的指定元素
對順序表進行動態(tài)的擴容和縮容

1. 準(zhǔn)備工作

實現(xiàn)工具	版本
IntelliJ IDEA	2021.3
JDK	1.8

在 IntelliJ IDEA 中新建普通的Java項目即可

在新建好Java工程后，我們創(chuàng)建自己的順序表類，在這里我對當(dāng)前類命名為Array，在這里實現(xiàn)泛型，同時Array類中需要有兩個成員屬性：

存放數(shù)據(jù)的數(shù)組：data，類型為泛型數(shù)組
當(dāng)前順序表中元素的數(shù)量：size，類型為int

兩個成員屬性的訪問權(quán)限都應(yīng)該為private，用戶不能夠直接進行修改，只能通過對應(yīng)的getter方法進行獲取。在成員屬性中我們將存放數(shù)據(jù)的數(shù)組和順序表中的元素數(shù)量只是進行了聲明，但是并未進行初始化，因此==初始化的過程就需要在構(gòu)造方法中進行==

有參構(gòu)造：在進行有參構(gòu)造時，我們只需要指定傳入的參數(shù)為一個int類型的數(shù)據(jù)capacity，代表順序表的初始容量，因此對data進行初始化泛型數(shù)組即可。同時當(dāng)前順序表中是沒有元素的，代表順序表中的元素個數(shù)size的初始值為0。
無參構(gòu)造：在用戶沒有指定了順序表的初始容量時我們可以自定義初始容量為10，僅需要通過this(10)進行有參構(gòu)造的調(diào)用即可。

注意： 在Java中不能直接初始化泛型數(shù)組，需要先聲明Object類型的數(shù)組后通過強制類型轉(zhuǎn)換的方式將Object類型的數(shù)組轉(zhuǎn)換為泛型數(shù)組

package net.csdn.array;
/**
 * @author zhangrongkang
 * @date 2022/6/26
 */
public class Array<E> {
	/**
	 * 存放數(shù)據(jù)的數(shù)組
	 */
	private E[] data;
    /**
     * 數(shù)組中元素的數(shù)量
     */
    private int size;
	
	/**
     * 構(gòu)造函數(shù)，傳入數(shù)組的容量capacity構(gòu)造數(shù)組
     *
     * @param capacity 初始數(shù)組大小
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 無參構(gòu)造函數(shù)，默認(rèn)數(shù)組大小為0
     */
    public Array() {
        this(10);
    }
}

使用泛型的原因：使用泛型后可以將當(dāng)前順序表中存儲對象，如果不使用泛型的話只能使用自己指定類型的數(shù)據(jù)，擴展性不強。因此使用泛型后可以將當(dāng)前順序表的使用擴展到所有類對象，只需要在創(chuàng)建時指定相應(yīng)的對象即可。

2. 獲取順序表的元素個數(shù)

    /**
     * 獲取數(shù)組中的元素個數(shù)
     *
     * @return 數(shù)組當(dāng)前的元素個數(shù)
     */
    public int getSize() {
        return size;
    }

對于獲取當(dāng)前順序表中的元素個數(shù)來說，因為我們定義的初始成員變量size代表的含義就是當(dāng)前順序表的元素個數(shù)，但是size變量的本質(zhì)為當(dāng)前順序表的指針，指向順序表最后一個元素的下一個位置 （元素的索引從0開始，最后一個元素的索引值比元素個數(shù)值小 1），不能直接進行修改，因此要想獲取需要通過size元素的getter方法

同樣地，對于獲取順序表的元素個數(shù)只需要將size返回即可

3. 獲取順序表當(dāng)前的容量

    /**
     * 獲取數(shù)組當(dāng)前容量
     *
     * @return 數(shù)組當(dāng)前容量
     */
    public int getCapacity() {
        return data.length;
    }

在對順序表進行聲明的時候，就已經(jīng)將用戶傳來的或者默認(rèn)的初始容量capacity作為數(shù)組的大小對data泛型數(shù)組進行了初始化，因此當(dāng)前data的length屬性就是傳來的capacity，（或者在后面進行動態(tài)擴容或縮容時，data.length是一直不會改變的，改變的只有size）因此獲取順序表當(dāng)前的容量將data.length返回即可

4. 順序表是否為空

    /**
     * 判斷數(shù)組是否為空
     *
     * @return 數(shù)組是否為空
     */
    public boolean isEmpty() {
        return size == 0;
    }

我們知道size代表的是順序表中的元素個數(shù)，因此要判斷當(dāng)前順序表是否為空僅需要將size是否等于0進行返回即可

5. 在指定索引位置添加元素

    /**
     * 向數(shù)組中索引為index位置添加元素e
     *
     * @param index 索引位置
     * @param e 元素e
     */
    public void add(int index, E e) {
        // 判斷數(shù)組空間是否已滿
        if (size == data.length) {
            // 對數(shù)組進行擴容
            resize(2 * data.length);
        }
        // 越界判斷
        if (index < 0 || index > size) {
            throw new ArrayIndexOutOfBoundsException();
        }

        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

當(dāng)向順序表中指定索引位置添加元素時要考慮以下幾個問題：

當(dāng)前順序表中是否還有容量？
添加的元素索引值是否越界？

對于第一個問題來說，當(dāng)順序表已滿沒有容量時，再進行添加元素時需要進行動態(tài)的擴容，resize方法的作用就是對數(shù)組進行動態(tài)的擴容以及縮容，對于resize方法的實現(xiàn)我們放到后面進行具體的講解，在這里我們知道如果當(dāng)前順序表容量已滿，將順序表容量擴大為當(dāng)前順序表容量的二倍

第二個問題的出現(xiàn)情況只有兩種，索引小于0或索引超過了當(dāng)前順序表中的元素個數(shù)時，拋出運行時異常即可

在索引沒有問題后，添加元素的過程如下圖所示：

要先將要添加的索引位置后的所有元素依次向后移動一位，在移動完成后將當(dāng)前索引位置的元素使用要進行添加的元素對當(dāng)前位置的元素進行覆蓋即可，同時添加完元素后將size++，維護指針變量

6. 在順序表末尾添加元素

    /**
     * 在數(shù)組末尾添加一個元素
     *
     * @param e 要添加的元素
     */
    public void addLast(E e) {
        add(size, e);
    }

在末尾添加元素可以對之前寫好的向指定索引位置添加元素的代碼進行復(fù)用，同時在add方法中進行了校驗，因此對于擴容以及索引都問題都無需我們進行考慮，將索引位置的參數(shù)賦值為當(dāng)前最后一個元素的下一個位置size 后直接調(diào)用即可。

7. 在順序表頭部添加元素

    /**
     * 在數(shù)組的頭部添加元素e
     *
     * @param e 要添加的元素
     */
    public void addFirst(E e) {
        add(0, e);
    }

在順序表的頭部添加元素也是同樣的道理，對指定索引位置插入元素進行復(fù)用即可，在此不進行贅述。

8. 獲取指定索引位置的元素

    /**
     * 獲取索引為index位置的元素
     *
     * @param index 索引位置
     * @return 索引為index位置的元素
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return data[index];
    }

獲取指定索引位置的元素與之前在指定索引位置插入元素的思路大體一致，但是要更簡單一些，無需考慮順序表擴容以及縮容的問題，僅需要考慮傳入的索引值是否合法，如果傳入的索引值合法則直接將對應(yīng)位置的元素進行返回即可。

9. 獲取順序表第一個元素

    /**
     * 獲取數(shù)組中第一個元素
     *
     * @return 數(shù)組中第一個元素
     */
    public E getFirst() {
        return get(0);
    }

在實現(xiàn)了獲取指定索引位置的元素后，獲取順序表的第一個元素同樣是對get方法的復(fù)用，將0做為索引值進行參數(shù)傳遞即可。

10. 獲取順序表最后一個元素

    /**
     * 獲取數(shù)組中最后一個元素
     *
     * @return 數(shù)組中最后一個元素
     */
    public E getLast() {
        return get(size - 1);
    }

獲取順序表最后一個元素也是對get方法的復(fù)用，在此不進行贅述

11. 修改指定索引位置的元素

    /**
     * 設(shè)置索引為index位置的元素值為e
     *
     * @param index 索引位置
     * @param e 要進行替換的元素值
     */
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        data[index] = e;
    }

在之前獲取指定索引位置的元素時，先判斷索引是否合法，如果合法將對應(yīng)位置的元素進行返回。同理，先判斷索引位置是否合法，如果合法就將當(dāng)前位置的元素使用我們接收到的元素e進行替換。

12. 判斷順序表中是否包含指定元素

    /**
     * 判斷數(shù)組中是否存在元素e
     *
     * @param e 元素e
     * @return 是否存在元素e
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

對于判斷順序表中是否存在指定元素來說，對順序表進行線性查找，如果找到了相應(yīng)的數(shù)據(jù)，就返回true，如果在對順序表遍歷結(jié)束后仍然沒有找到指定元素，說明當(dāng)前順序表中不存在指定元素，返回false

注意：在這里因為是對象的比較，使用equals方法進行比較，如果是基本數(shù)據(jù)類型（如int，double等）的比較就要使用==來進行比較

13. 獲取順序表中指定元素的索引

    /**
     * 查找數(shù)組中元素e的索引，如果不存在返回 -1
     *
     * @param e 元素e
     * @return 元素e在數(shù)組中的索引
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

獲取指定元素的索引同樣使用線性查找法，使用equals進行比較，如果找到相同的元素則返回對應(yīng)的索引值，如果遍歷完順序表后仍然沒有找到指定元素則返回-1，說明當(dāng)前元素不存在。

14. 刪除指定索引位置的元素

    /**
     * 刪除索引位置為 index 的元素并返回被刪除的元素
     *
     * @param index 刪除元素的索引
     * @return 被刪除的元素
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        // 先將返回值進行存儲
        E res = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        data[size] = null;
        // 如果當(dāng)前數(shù)組中的元素不足數(shù)組容量的一半
        if (size < data.length / 2) {
            // 重新分配空間
            resize(data.length / 2);
        }
        return res;
    }

在之前進行元素的添加時要考慮順序表是否還有容量，在刪除元素時不需要考慮是否還有容量，但是也要考慮相應(yīng)的有關(guān)于數(shù)組縮容問題。因此要考慮以下問題：

刪除當(dāng)前元素后，順序表中的元素個數(shù)是否不足數(shù)組容量的一半？
刪除指定索引的元素時，傳來的索引值是否合法？

對于第一個問題的解決方法為在刪除元素后，對當(dāng)前順序表的元素個數(shù)與數(shù)組的容量的一半進行比較，如果發(fā)現(xiàn)當(dāng)前元素個數(shù)小于數(shù)組容量的一半時，我們可以繼續(xù)調(diào)用resize方法重新分配數(shù)組的容量（resize方法在之后會詳細(xì)解釋），當(dāng)前的實現(xiàn)結(jié)果就是將數(shù)組的容量縮容至原數(shù)組都一半，對于內(nèi)存的節(jié)省來說更有好處。

第二個問題解決方式與之前處理一樣，查看索引值是否小于0以及是否大于等于當(dāng)前順序表都元素個數(shù)

刪除元素的本質(zhì)也是將當(dāng)前索引值的后一個元素開始，依次向前移動，覆蓋掉前一個元素，最后再將size--，維護指針，刪除結(jié)束后將臨時存儲的被刪除的元素返回即可。

刪除元素過程如下圖所示：

注意：順序表的刪除本質(zhì)上是用后一個元素將前一個元素依次覆蓋，移動了size指針后此時指針指向的元素仍然為原本順序表中的最后一個元素，因為在用戶的實際操作中，size指向的元素?zé)o法被訪問到，所以并沒有什么影響。但是我們在這里使用了泛型，在Java的GC（垃圾回收機制）中因為此時順序表的最后一個元素仍然被size指向引用，無法被回收，因此在這里手動執(zhí)行data[size] = null;將當(dāng)前的引用回收。

15. 刪除并返回順序表第一個元素

    /**
     * 刪除并返回數(shù)組的第一個元素
     *
     * @return 數(shù)組的第一個元素
     */
    public E removeFirst() {
        return remove(0);
    }

與之前的思路一致，在有了刪除指定索引位置的元素方法后，刪除并返回順序表第一個元素也是對剛才實現(xiàn)的remove方法進行復(fù)用，在此不做贅述。

16. 刪除并返回順序表最后一個元素

    /**
     * 刪除并返回數(shù)組中的最后一個元素
     *
     * @return 數(shù)組中的最后一個元素
     */
    public E removeLast() {
        return  remove(size - 1);
    }

刪除順序表中最后一個元素同樣是對remove方法的復(fù)用，在此也不多做贅述。

17. 刪除順序表中的指定元素

    /**
     * 從數(shù)組中刪除元素e
     *
     * @param e 數(shù)組中被刪除的元素
     * @return 是否刪除成功
     */
    public boolean removeElement(E e) {
       int index = find(e);
       if (index == -1) {
           return false;
       }
       remove(index);
       return true;
    }

刪除順序表中指定的元素本質(zhì)上是對之前實現(xiàn)的獲取順序表中指定元素的索引方法和刪除指定索引位置元素方法的復(fù)用，首先通過find方法獲取到要刪除元素的索引，接著對索引進行判斷，查看當(dāng)前元素是否存在，如果當(dāng)前元素存在則將獲取到的索引值作為remove方法的參數(shù)傳遞，將當(dāng)前索引位置的元素刪除即可。

18. 對順序表進行動態(tài)的擴容和縮容

    /**
     * 對數(shù)組進行擴容
     *
     * @param newCapacity 擴容后數(shù)組的容量
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

在之前向順序表中添加元素以及刪除順序表中的元素都涉及到了擴容以及縮容的過程，其實對于擴容以及縮容來說區(qū)別只體現(xiàn)在了傳遞來的參數(shù)與原數(shù)組容量大小的差別，擴容與縮容的思路都是聲明一個新的數(shù)組，初始容量的大小為傳遞來的參數(shù)，接著遍歷原來的數(shù)組，將每一個元素依次填充到新的數(shù)組中，之后再將data對象的引用指向新的數(shù)組newData即可。

三、運行結(jié)果

在進行結(jié)果測試前，為了方便于觀察，在這里我重寫了Array類的toString方法

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

四、總結(jié)

以上便是Java語言對線性表的順序表示和實現(xiàn)，和以前使用C語言來寫順序表最大的感受就是曾經(jīng)覺得很難寫、很費腦的代碼再次實現(xiàn)時感覺變得很容易了，同時對于很多的方法也有了復(fù)用的思想，對線性表的理解更加深刻。高興于自己成長的同時也更加深刻意識到以后的路會更加的艱難，希望自己可以在未來的道路上戒驕戒躁、穩(wěn)扎穩(wěn)打，哪怕再困難，也不會放棄！

源碼

以下是源代碼

1. Array類源代碼

package net.csdn.array;
/**
 * @author zhangrongkang
 * @date 2022/6/26
 */
public class Array<E> {
    private E[] data;
    /**
     * 數(shù)組中元素的數(shù)量
     */
    private int size;

    /**
     * 構(gòu)造函數(shù)，傳入數(shù)組的容量capacity構(gòu)造數(shù)組
     *
     * @param capacity 初始數(shù)組大小
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 無參構(gòu)造函數(shù)，默認(rèn)數(shù)組大小為0
     */
    public Array() {
        this(10);
    }

    /**
     * 獲取數(shù)組中的元素個數(shù)
     *
     * @return 數(shù)組當(dāng)前的元素個數(shù)
     */
    public int getSize() {
        return size;
    }

    /**
     * 獲取數(shù)組當(dāng)前容量
     *
     * @return 數(shù)組當(dāng)前容量
     */
    public int getCapacity() {
        return data.length;
    }
    /**
     * 判斷數(shù)組是否為空
     *
     * @return 數(shù)組是否為空
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在數(shù)組末尾添加一個元素
     *
     * @param e 要添加的元素
     */
    public void addLast(E e) {
        add(size, e);
    }
    /**
     * 在數(shù)組的頭部添加元素e
     *
     * @param e 要添加的元素
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 向數(shù)組中索引為index位置添加元素e
     *
     * @param index 索引位置
     * @param e 元素e
     */
    public void add(int index, E e) {
        // 判斷數(shù)組空間是否已滿
        if (size == data.length) {
            // 對數(shù)組進行擴容
            resize(2 * data.length);
        }
        // 越界判斷
        if (index < 0 || index > size) {
            throw new ArrayIndexOutOfBoundsException();
        }

        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }
    /**
     * 獲取索引為index位置的元素
     *
     * @param index 索引位置
     * @return 索引為index位置的元素
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return data[index];
    }
    /**
     * 獲取數(shù)組中第一個元素
     *
     * @return 數(shù)組中第一個元素
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 獲取數(shù)組中最后一個元素
     *
     * @return 數(shù)組中最后一個元素
     */
    public E getLast() {
        return get(size - 1);
    }

    /**
     * 設(shè)置索引為index位置的元素值為e
     *
     * @param index 索引位置
     * @param e 要進行替換的元素值
     */
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        data[index] = e;
    }
    /**
     * 判斷數(shù)組中是否存在元素e
     *
     * @param e 元素e
     * @return 是否存在元素e
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找數(shù)組中元素e的索引，如果不存在返回 -1
     *
     * @param e 元素e
     * @return 元素e在數(shù)組中的索引
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 刪除索引位置為 index 的元素并返回被刪除的元素
     *
     * @param index 刪除元素的索引
     * @return 被刪除的元素
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        // 先將返回值進行存儲
        E res = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        data[size] = null;
        // 如果當(dāng)前數(shù)組中的元素不足數(shù)組容量的一半
        if (size < data.length / 2) {
            // 重新分配空間
            resize(data.length / 2);
        }
        return res;
    }

    /**
     * 刪除并返回數(shù)組的第一個元素
     *
     * @return 數(shù)組的第一個元素
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 刪除并返回數(shù)組中的最后一個元素
     *
     * @return 數(shù)組中的最后一個元素
     */
    public E removeLast() {
        return  remove(size - 1);
    }
    /**
     * 從數(shù)組中刪除元素e
     *
     * @param e 數(shù)組中被刪除的元素
     * @return 是否刪除成功
     */
    public boolean removeElement(E e) {
       int index = find(e);
       if (index == -1) {
           return false;
       }
       remove(index);
       return true;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array: size = %d, capacity = %d\n", size, data.length));
        builder.append("[");
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append("]");
        return builder.toString();
    }
    /**
     * 對數(shù)組進行擴容
     *
     * @param newCapacity 擴容后數(shù)組的容量
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }
}

2. 測試類源代碼

package net.csdn.array;

/**
 * @author zhangrongkang
 * @date 2022/6/26
 */
public class ArrayMain {
    public static void main(String[] args) {
        System.out.println("聲明新的順序表，初始容量為10：");
        Array<Integer> array = new Array<>(10);
        for (int i = 0; i < 10; i++) {
            array.addLast(i);
        }
        System.out.println(array + "\n");

        System.out.println("向索引為 1 的位置添加元素 100：");
        array.add(1, 100);
        System.out.println(array + "\n");

        System.out.println("在順序表的頭部添加 -1：");
        array.addFirst(-1);
        System.out.println(array + "\n");

        System.out.println("在順序表的尾部添加 101：");
        array.addLast(101);
        System.out.println(array + "\n");

        System.out.println("移除索引位置為 2 的元素：");
        array.remove(2);
        System.out.println(array + "\n");

        System.out.println("移除順序表中的元素 4：");
        array.removeElement(4);
        System.out.println(array + "\n");

        System.out.println("移除順序表中的第一個元素：");
        array.removeFirst();
        System.out.println(array + "\n");

        System.out.println("移除順序表中的最后一個元素：");
        array.removeLast();
        System.out.println(array + "\n");

        System.out.println("元素7的索引位置為：" + array.find(7));
        System.out.println("數(shù)組中是否包含元素4：" + array.contains(4));
    }

}

到此這篇關(guān)于Java線性表的順序表示及實現(xiàn)的文章就介紹到這了,更多相關(guān)Java線性表內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: