手寫數組的底層實現(java實現)

原創 央小木 2020-06-01 18:11

文章目錄

打造屬於自己的Array

​ 查看JDK1.8中ArrayList源碼時，其中的Arrays.copyOf爲Native方法，具體怎麼實現的並沒有。所以打算自己實現，來深入瞭解一下Array這個數據結構。

靜態數組

創建增刪改查方法

在這裏插入圖片描述

  1. 自己創建數組無非就是數組的 增刪改查 方法的創建，即 add,remove,set,get 方法。

  2. 首先創建一個簡單的int集合來表示數組，默認大小爲10，添加一些常規的方法之後，再對重要的方法進行單獨書寫

  3. add方法：在指定索引位置插入數字，就相當於把指定索引處後的值往後移一位，即把值賦給下一個索引，一層for循環就可以，同時不要忘記size++,然後再在指定索引處賦值。

  4. remove方法：在指定索引位置刪除數字，就相當於把指定索引處後的值往前移一位，即把值賦給上一個索引，一層for循環就可以，同時不要忘記size–。這裏有所不同，即int[size]的值需不需要刪除，其實這裏刪不刪除並不影響數組的邏輯和功能實現，但本着嚴謹的態度，將int[size]賦值爲null，節省一點內存空間。

    package design.Array;

/**
 * @program: design
 * @description: Array類
 * @author: cyj
 * @create: 2019-03-18 21:23
 **/
public class Array {
    private int[] data;
    private int size;

    /**
     * 構造函數，傳入數組的容量capacity構造Array
     *
     * @param capacity
     */
    public Array(int capacity) {
        data = new int[capacity];
        size = 0;
    }

    /**
     * 無參數的構造函數，默認數組的容量capacity=10
     */
    public Array() {
        this(10);
    }

    /**
     * 獲取數組中的元素個數
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 獲取數組的容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 返回數組是否爲空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 向所有元素後添加一個新元素e
     *
     * @param e
     */
    public void addLast(int e) {
//        if (size == data.length) {
//            throw new IllegalArgumentException("AddLast failed.Array is full.");
//        }
//        data[size] = e;
//        size++;
        add(size, e);
    }

    /**
     * 向所有元素前添加一個新元素e
     *
     * @param e
     */
    public void addFirst(int e) {
        add(0, e);
    }

    /**
     * 在第index個位置插入一個新元素e
     *
     * @param index
     * @param e
     */
    public void add(int index, int e) {
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed.Array is full.");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.Require index >=0 is full.");
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    /**
     * 獲取index索引位置的元素
     *
     * @param index
     * @return
     */
    int get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Get failed.Require index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素爲e
     *
     * @param index
     * @param e
     */
    void set(int index, int e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Set failed.Require index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 查找數據中是否有元素e
     *
     * @param e
     * @return
     */
    public boolean contains(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

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

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     *
     * @param index
     * @return
     */
    public int remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Remove failed.Require index is illegal.");
        }
        int ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        return ret;
    }

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     *
     * @return
     */
    public int removeFirst() {
        return remove(0);
    }

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     *
     * @return
     */
    public int removeLast() {
        return remove(size - 1);
    }

    /**
     * 從數組中刪除元素e
     * 1. 可以返回boolean  2.重複數組的考量，刪除所有的元素e,設計上的考慮，具體需求具體分析
     *
     * @param e
     */
    public void removeElement(int e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

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

測試靜態數組類

package design.Array;

/**
 * @program: design
 * @description: 測試Array類
 * @author: cyj
 * @create: 2019-03-19 10:02
 **/
public class ArrayTest {
    public static void main(String[] args) {
        Array arr = new Array(20);
        for (int i = 0; i < 10; i++) {
            arr.addLast(i);
        }
        System.out.println(arr);

        arr.add(1, 100);
        System.out.println(arr);

        arr.addFirst(-1);
        //[-1,0,100,1,2,3,4,5,6,7,8,9]
        System.out.println(arr);

        arr.remove(2);
        //[-1,0,1,2,3,4,5,6,7,8,9]
        System.out.println(arr);

        arr.removeElement(4);
        //[-1,0,1,2,3,5,6,7,8,9]
        System.out.println(arr);

        arr.removeFirst();
        //[0, 1, 2, 3, 5, 6, 7, 8, 9]
        System.out.println(arr);
    }
}

輸出結果(重寫類的toString方法)：
Array: size=10 , capacity=20
[0,1,2,3,4,5,6,7,8,9]

Array: size=11 , capacity=20
[0,100,1,2,3,4,5,6,7,8,9]

Array: size=12 , capacity=20
[-1,0,100,1,2,3,4,5,6,7,8,9]

Array: size=11 , capacity=20
[-1,0,1,2,3,4,5,6,7,8,9]

Array: size=10 , capacity=20
[-1,0,1,2,3,5,6,7,8,9]

Array: size=9 , capacity=20
[0,1,2,3,5,6,7,8,9]

泛型和動態數組的實現

泛型

在實際運用中，我們不能只是簡單的用整數型數組來表示，這裏就要引出泛型的概念。

  • 泛型，即“參數化類型”。一提到參數，最熟悉的就是定義方法時有形參，然後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢？

    顧名思義，就是將類型由原來的具體的類型參數化，類似於方法中的變量參數，此時類型也定義成參數形式（可以稱之爲類型形參），然後在使用/調用時傳入具體的類型（類型實參）。

    泛型的本質是爲了參數化類型（在不創建新的類型的情況下，通過泛型指定的不同類型來控制形參具體限制的類型）。也就是說在泛型使用過程中，操作的數據類型被指定爲一個參數，這種參數類型可以用在類、接口和方法中，分別被稱爲泛型類、泛型接口、泛型方法。

  • 因爲不能直接定義泛型，所以可以通過定義Object的方式來強轉爲泛型

  • 定義了泛型之後就可以接收的多種類型，因爲泛型把具體的參數類型泛化，模糊化，使得傳參可以有更多種的選擇。

動態數組

動態數組的實現即實現了數組的擴容。擴容的過程是

  • 是否超出了默認的數組長度，超出則執行擴容方法

  • 擴容是新建一個數組，新建數組的長度爲原數組的2倍(ArrayList爲1.5倍,通過位運算來計算),接着把原數組的值通過for循環來賦值到新數組，在接着把原數組的引用指向新數組。

  • 在增加和刪除的時候進行擴容和縮容(新建一個爲原數組長度1/2的新數組)

  • 在數組縮容的問題上，爲了防止複雜度的震盪，數組在長度邊緣瘋狂的試探，頻繁的進行擴容和縮容。(即數組長度爲10，增加一個元素擴大爲20，之後緊接着又刪除一個元素，又縮容爲10)。

    所以縮容的時候判斷數組實際長度爲1/4時才進行縮容，就可以減少瘋狂的試探，從而防止方法的時間複雜度一直爲O(n)。

package design.Array;

/**
 * @program: design
 * @description: Array類
 * @author: cyj
 * @create: 2019-03-18 21:23
 **/
public class ArrayObject<E> {
    private E[] data;
    private int size;

    /**
     * 構造函數，傳入數組的容量capacity構造Array
     *
     * @param capacity
     */
    public ArrayObject(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 無參數的構造函數，默認數組的容量capacity=10
     */
    public ArrayObject() {
        this(10);
    }

    /**
     * 獲取數組中的元素個數
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 獲取數組的容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 返回數組是否爲空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 向所有元素後添加一個新元素e
     * 時間複雜度：O(1)
     *
     * @param e
     */
    public void addLast(E e) {
//        if (size == data.length) {
//            throw new IllegalArgumentException("AddLast failed.Array is full.");
//        }
//        data[size] = e;
//        size++;
        add(size, e);
    }

    /**
     * 向所有元素前添加一個新元素e
     * 時間複雜度：O(n)
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在第index個位置插入一個新元素e
     * 時間複雜度：O(n/2)=>O(n)
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.Require index >=0 is full.");
        }
        if (size == data.length) {
            resize(2 * data.length);
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    /**
     * 獲取index索引位置的元素
     * 時間複雜度：O(1)
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Get failed.Require index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素爲e
     * 時間複雜度：O(1)
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Set failed.Require index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 查找數據中是否有元素e
     * 時間複雜度：O(n)
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找數組中元素e所在的索引，如果不存在則返回索引爲-1
     * 時間複雜度：O(n)
     *
     * @param e
     * @return
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     * 時間複雜度：O(n/2)=>O(n)
     *
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Remove failed.Require index is illegal.");
        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        //loireting objects !=memory leak,不寫的話邏輯上也正確
        data[size] = null;
        //防止複雜度震盪，所以1/4  防止刪到最後一位
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return ret;
    }

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     * 時間複雜度：O(n)
     *
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 從數組中刪除index位置的元素，返回刪除的元素
     * 時間複雜度：O(1)
     *
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }

    /**
     * 從數組中刪除元素e
     * 1. 可以返回boolean  2.重複數組的考量，刪除所有的元素e,設計上的考慮，具體需求具體分析
     *
     * @param e
     */
    public void removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

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

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }
}

測試動態數組類

泛型測試類

package design.Array;

/**
 * @program: design
 * @description: 測試泛型類數組實體類
 * @author: cyj
 * @create: 2019-03-19 11:44
 **/
public class Test {
    private String name;
    private String age;

    public Test(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return String.format("Student(name: %s, age: %s)", name, age);
    }

    public static void main(String[] args) {
        ArrayObject<Test> arrayObject = new ArrayObject<>();
        arrayObject.addLast(new Test("sangsan", "21"));
        arrayObject.addLast(new Test("lisi", "22"));
        arrayObject.addLast(new Test("wangwu", "23"));
        System.out.println(arrayObject);
    }
}

輸出結果：
Array: size=3 , capacity=10
[Student(name: sangsan, age: 21), Student(name: lisi, age: 22), Student(name: wangwu, age: 23)]

動態數組測試類

package design.Array;

/**
 * @program: design
 * @description: 測試ArrayObject類
 * @author: cyj
 * @create: 2019-03-19 10:02
 **/
public class ArrayTestObject {
    public static void main(String[] args) {
        ArrayObject<Integer> arr = new ArrayObject<>();
        for (int i = 0; i < 10; i++) {
            arr.addLast(i);
        }
        System.out.println(arr);

        arr.add(1, 100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);

        arr.remove(2);
        System.out.println(arr);

        arr.removeElement(4);
        System.out.println(arr);

        arr.removeFirst();
        System.out.println(arr);
    }
}

輸出結果(可以看出來數組的長度在變化了)：
Array: size=10 , capacity=10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=11 , capacity=20
[0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=12 , capacity=20
[-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=11 , capacity=20
[-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size=10 , capacity=20
[-1, 0, 1, 2, 3, 5, 6, 7, 8, 9]
Array: size=9 , capacity=20
[0, 1, 2, 3, 5, 6, 7, 8, 9]

數組的底層實現就先寫到這裏，可以看出效果還是可以的，之後會繼續基於數組來實現棧，隊列。
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

劍指Offer-在排序數組中查找數字 I

46.在排序數組中查找數字 I 統計一個數字在排序數組中出現的次數。 示例 1: 輸入: nums = [5,7,7,8,8,10], target = 8 輸出: 2 示例 2: 輸入: nums = [5,7,7,8,8,

Ga_Lip 2020-07-08 12:20:23

LeetCode-452. 用最少數量的箭引爆氣球

LeetCode-452. 用最少數量的箭引爆氣球 在二維空間中有許多球形的氣球。對於每個氣球，提供的輸入是水平方向上，氣球直徑的開始和結束座標。由於它是水平的，所以y座標並不重要，因此只要知道開始和結束的x座標就足夠了。開始座標

Ga_Lip 2020-07-08 12:20:23

LeetCode-680. 驗證迴文字符串

LeetCode-680. 驗證迴文字符串 給定一個非空字符串 s，最多刪除一個字符。判斷是否能成爲迴文字符串。 示例 1: 輸入: "aba" 輸出: True 示例 2: 輸入: "abca" 輸出: True 解釋: 你可

Ga_Lip 2020-07-08 12:20:23

基本數據結構——線性結構（列表/無序表）

1.什麼是列表（List）? 一個數據項按照相對位置存放的數據集。特別的，被稱爲“無序表(unordered list)”，其中數據項只按照存放位置來索引，如第1個、第2個…、最後一個等。 如一個考試分數的集合“54,26,93,

weixin_38324954 2020-07-08 11:06:53

算法複雜度評價指標（大o表示法）

大O表示法（1）常見的大o數量級函數（2）其他算法複雜度表示法 基本操作數量函數T(n)的精確值並不是特別重要，重要的是Tn(n)中起決定性因素的主導部分。用動態的眼光看，就是當問題規模增大的時候，T(n)中的一些部分會蓋過其他部

weixin_38324954 2020-07-08 11:06:52

“變位詞”判斷問題及算法複雜度

解法1 逐字檢查 解法思路： 將詞1中的字符逐個到詞2中檢查是否存在，存在就打勾標記（防止重複檢查）。如果每個字符都能找到，則兩個詞是變位詞。只要有一個字符找不到，就不是變位詞。 實現打勾標記：將詞2對應字符設爲None,由於

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（有序表）

1. 什麼是有序表（OrderedList） 有序表是一種數據項依照其某可比性質（如整數大小、字母表先後）來決定在列表中的位置。越“小”的數據項越靠近列表的頭，越靠“前”。 2.抽象數據類型有序表（OrderedList）定義的

weixin_38324954 2020-07-08 11:06:52

python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級

python兩種內置數據類型（列表list和字典dict）上各個操作的大O數量級 1.對比list和dict操作 2.list列表數據類型常用操作性能 (1)按索引取值和賦值（v=a[i],a[i]=v） 由於列表的隨機訪問特性

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

基本數據結構——線性結構（隊列、雙端隊列）

1. 什麼是隊列？ 隊列是一種有次序的數據集合，其特徵是新數據項的添加總髮生在一端（通常稱爲“尾端”），而現存數據項的移除總髮生在另一端（通常稱爲“首front”端）。 新加入的數據項必須在數據集末尾等待，而等待時間最長的數據項則

weixin_38324954 2020-07-08 11:06:52

遞歸(Recursion)及其應用

1. 什麼是遞歸 遞歸是一種解決問題的方法，其精髓在於將問題分解爲規模更小的相同問題，持續分解，直到問題規模小到可以用非常簡單直接的方式來解決。 遞歸問題分解方式非常獨特，其算法方面的明顯特徵就是：在算法流程中調用自身。 2. 遞

weixin_38324954 2020-07-08 11:06:52

未理解的題

關於樹的深度優先搜索算法描述錯誤的是 A : 按照某個條件往前試探搜索,如果前進中遭遇失敗, 則退回頭另選通路繼續搜索,直到找到條件目標爲止 B: 先訪問該節點所有的子節點, 遍歷完畢後選取它未訪問過的子節點重複上述過程,直到找到

harkecho 2020-07-08 10:56:02

按位與& 和 模運算 % 的關係

unsigned int MAX = 32; // 2的5次方 unsigned int index = 31; index = (index + 100) % MAX; printf ("inde

harkecho 2020-07-08 10:56:02

位運算判斷兩個數是否異號

首先介紹下負數在計算機中的表示和存儲 在計算機系統中，數值一律用補碼錶示和存儲。含符號位和數值位，符號位：0表示“正”； 1表示“負”。 正數的補碼 = 原碼 負數的補碼 = 負數的原碼取反（符號位保持不變）+ 1 列如 比如

harkecho 2020-07-08 10:56:01

按位或與加法的區別

0 | 0 = 0 1 | 1 = 1 0 | 1 = 1 1 | 0 = 1 0 ^ 0 = 0 1 ^ 1 = 0 0 ^ 1 = 1 1 ^ 0 = 1 0 & 0 = 0 1 &

harkecho 2020-07-08 10:56:01