# 手寫 ArrayList 核心原始碼

## 手寫 ArrayList 核心原始碼

ArrayList 是 Java 中常用的資料結構，不光有 ArrayList，還有 LinkedList,HashMap,LinkedHashMap,HashSet,Queue，PriorityQueue 等等，我們將手寫這些常用的資料結構的核心原始碼，用盡量少的程式碼來揭示核心原理。

下面我們來手寫 ArrayList 的核心原始碼

首先我們定義一個 QArrayList，不要問為什麼叫 QArrayList，因為我之前寫過 Qt，僅此而已。原始碼 `public class<t> QArrayList`,Java 中的 ArrayList 的底層就是用一個 Object [] 結構來儲存資料的。我們也要定義一個 Object [] 屬性。

而且我們還要定義一個預設的資料的大小，以便在呼叫預設建構函式的情況下使用。 `private final int DEFAULT_LIST_SIZE = 8;`

還要定義一個 `int mSize` 變數，`mSize 預設為0`，**代表下一個可以存放資料的陣列的索引**，**代表下一個可以存放資料的陣列的索引**，**代表下一個可以存放資料的陣列的索引** 重要的事情說三遍

到現在為止我們的類如下：

```java
public class QList<t> {
    //預設的陣列的大小
    private final int DEFAULT_LIST_SIZE = 8;

//存放資料的地方
    private Object[] mData;
    
    //下一個可以存放資料的當前陣列的索引
    private int mSize;
    
    ......
}    
```

好了，存放資料的陣列也有了，下一個可以存放資料的當前的陣列的索引也有了 ArrayList 底層是用陣列存放資料，那麼會有一個問題，如果此時陣列滿了我們再往裡面存放資料的時候，怎麼辦呢？ArrayList 是再新建一個陣列，新陣列的大小是原來陣列大小的 2 倍，那麼我們也這樣做。博主的環境都是部署在[cnaaa伺服器](https://www.cnaaa.com/)上的。

此時，我們實現 add,get,remove,resize 等這幾個核心方法，QArrayList 完整的程式碼如下 ：

```java
public class QArrayList<t> {
    //預設的陣列的大小
    private final int DEFAULT_LIST_SIZE = 8;

//存放資料的地方
    private Object[] mData;

//下一個可以存放資料的當前陣列的索引
    private int mSize;

public QArrayList() {
        //new 一個陣列，用來存放
        mData = new Object[DEFAULT_LIST_SIZE];

//下一個可以存放資料的當前陣列的索引為0
        mSize = 0;
    }

public QArrayList(int capacity){
        if(capacity <= 0 || capacity > Integer.MAX_VALUE){
            throw new RuntimeException("invalid capacity");
        }

mData = new Object[capacity];
        mSize = 0;
    }

//返回當時陣列的已經存放了多少個元素
    public int size() {
        return mSize;
    }

//返回陣列的總大小，其實這個介面沒有必要對外提供，這裡我們只是為了演示用
    public int capacity() {
        return mData.length;
    }

//新增一個元素
    public void add(T e) {
        //規定不允許新增一個空元素
        if(e == null){
            return;
        }

//如果當前陣列已經滿了，擴容為原來陣列的2倍
        if (mSize >= mData.length) {

//擴容
            resize();
        }

//將新增的元素新增到陣列中
        mData[mSize] = e;

//同時 mSize++ 指向下一個可以存放資料的位置
        mSize++;
    }

//獲取指定位置的元素，如果position不合法，直接丟擲異常
    //這樣做是有必要的，我們提供的是一個庫
    // 直接丟擲異常讓使用知道用錯了，沒有必要 return null
    // 因為這是個庫，不是業務，就算return null，也是業務層的事
    public T get(int position) {
        if (position < 0 || position >= mData.length) {
            throw new RuntimeException("position is invalid");
        }

// position 大於 mSize 也沒有關係，因為也是返回null，證明沒有獲取到
        return (T) mData[position];
    }

//刪除指定位置的元素
    public T remove(int position) {
        //和上面一樣，位置不合法直接丟擲異常
        if (position < 0 || position >= mData.length) {
            throw new RuntimeException("position is invalid");
        }

//把當前要刪除的元素儲存下來，最後返回要刪除的元素
        T e = (T) mData[position];

//刪除後，把後面的所有元素都往前移位
        for (int i = position + 1; i < mData.length; i++) {
            mData[i - 1] = mData[i];
        }

//別忘了 mSize 要 --
        mSize--;

//返回刪除的元素
        return e;
    }

//刪除指定的元素
    public boolean remove(T e) {
        //因為陣列可能沒有滿，如果刪除的是null，沒有必要，我們不允許
        if (e == null) {
            return false;
        }

//找到刪除元素的位置
        int position = -1;
        for (int i = 0; i < mData.length; i++) {
            if (e == mData[i] || e.equals(mData[i])) {
                position = i;
                break;
            }
        }

//沒有找到就返回
        if (position == -1) {
            return false;
        }

//刪除
        return remove(position) != null;
    }

//擴容,我們都以2倍的容量擴容
    private void resize() {
        Object[] old = mData;
        mData = new Object[mData.length * 2];
        for (int i = 0; i < old.length; i++) {
            mData[i] = old[i];
        }

old = null;
    }
}
```

註釋都有相關的解釋 我們來測試，測試程式碼如下：

```java
    public static void main(String[] args) {
        QArrayList<string> list = new QArrayList<>();
        list.add("tom");
        list.add("jim");
        list.add("lilei");
        list.add("hanmeimei");

System.out.println("list.get(2)=" + list.get(2));
        System.out.println("list.size()=" + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.println("list.get(" + i + ") = " + list.get(i));
        }

System.out.println("=======================");
        System.out.println("演示刪除操作");
        list.remove("jim");

for (int i = 0; i < list.size(); i++) {
            System.out.println("list.get(" + i + ") = " + list.get(i));
        }
    }
    
```

輸出如下： list.get (2)=lilei list.size ()=4 list.get (0) = tom list.get (1) = jim list.get (2) = lilei list.get (3) = hanmeimei ============ 演示刪除操作 list.get (0) = tom list.get (1) = lilei list.get (2) = hanmeimei

**但是最重要的擴容功能還沒有演示，下面是擴容演示的測試程式碼：**

```java
 public static void main(String[] args) {
        //新建一個只有2個元素的陣列
        QArrayList<string> list = new QArrayList<>(2);

//列印出擴容後的容量
        System.out.println("擴容前 ： list.capacity()=" + list.capacity());

//我們新增了4個元素
        list.add("tom");
        list.add("jim");
        list.add("lilei");
        list.add("hanmeimei");

//列印出擴容後的容量
        System.out.println("擴容後 ： list.capacity()=" + list.capacity());

//列印
        for (int i = 0; i < list.size(); i++) {
            System.out.println("list.get(" + i + ") = " + list.get(i));
        }
    }
```

輸出如下：

擴容前 ： list.capacity ()=2 擴容後 ： list.capacity ()=4 list.get (0) = tom list.get (1) = jim list.get (2) = lilei list.get (3) = hanmeimei

可以看到，我們新建了一個底層只有 2 個元素的陣列，但是我們新增了 4 個元素，我們列印出擴容後的陣列的容量是 4 ，可見我們的擴容機制是沒有問題的。

以上就是 QArrayList 的核心原理，我們下節手寫 LinkedList 的核心原理</string></string></t></t></t>

手寫 ArrayList 核心原始碼

相關文章