ArrayList模拟实现

ArrayList 的初步介绍

ArrayList也叫做顺序表，底层是一个数组。

在创建顺序表 时就应该规定 里面元素的数据类型，其中不能直接传基本数据类型，例如int、char。需要传他们的包装类。

常见操作

插入元素需要调用add方法，java也提供了下列的add方法。

对于这种 add 方法，默认是尾插，所以打印结果为1 2 3 4.

还有一种 add 方法是 在指定下标插入一个元素。

下标为1的值是2的那个位置，所以最终会打印 1 5 2 3 4

想要删除元素需要调用 remove函数。

可以指定值删除，也可以指定下标删除。

ArrayList的其他操作可以看帮助手册或者看源码。

ArrayList 的简单模拟实现

成员变量需要有一个数组和 一个size ，这个size代表数组当中有效数据的个数。

构造方法中含有对数组的初始化。

add方法：

每次add都需要检查一下数组是否满了，如果满了，则需要扩容

在指定下标插入一个元素的add方法：

contains 方法：（查询一个值是否在顺序表当中存在）

getIndex方法：（查询一个值在顺序表当中对应的下标，如果找不到则返回-1）

remove 方法：（删除第一次出现的data）

EmptyException异常:

检查是否顺序表为空：

获取对应下标元素的值：

其余方法：

package test;

import java.util.Arrays;
import java.util.StringJoiner;

public class MyArraylist {
    private int[] elem;
    private int size;

    private static final int DEFAULT_SIZE = 10;

    public MyArraylist() {
        elem = new int[DEFAULT_SIZE];
    }

    public void add(int data) {
        checkCapacity();
        elem[size++] = data;
    }

    public void add(int index, int data) {
        checkCapacity();
        try {
            if (index == size) {
                add(data);
                return;
            }
            checkIndex(index);
            for (int i = this.size; i > index; i--) {
                elem[i] = elem[i - 1];
            }
            elem[index] = data;
            size++;
        } catch (PosIllegalException e) {
            e.printStackTrace();
        }

    }

    public boolean contains(int toFind) {
        int index = getIndex(toFind);
        return index != -1;
    }


    public int getIndex(int toFind) {
        for (int i = 0; i < this.size; i++) {
            if (elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    //删除第一次出现的data
    public void remove(int data) {
        try
        {
            checkEmpty();
            for (int i = 0; i < this.size; i++) {
                if (elem[i] == data) {
                    for (int j = i; j < size - 1; j++) {
                        elem[j] = elem[j + 1];
                    }
                    size--;
                    break;
                }
            }
        } catch (EmptyException e) {
            e.printStackTrace();
        }
    }

    private void checkEmpty() {
        if (isEmpty()) {
            throw new EmptyException("顺序表为空");
        }
    }
    public int get(int index) {
        try {
            checkIndex(index);
            return elem[index];
        } catch (PosIllegalException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public void clear() {
        size = 0;
    }

    public void set(int pos, int val) {
        try {
            checkIndex(pos);
            elem[pos] = val;
        } catch (PosIllegalException e) {
            e.printStackTrace();
        }

    }

    private void checkIndex(int index) throws PosIllegalException{
        if (!(index >= 0 && index < size)) {
            throw new PosIllegalException("pos位置不合法");
        }
    }


    private void checkCapacity() {
        if (this.size != elem.length) {
            return;
        }
        elem = Arrays.copyOf(elem, elem.length * 2);
    }

    public String toString() {
        StringJoiner sj = new StringJoiner(", ", "[", "]");
        for (int i = 0; i < this.size; i++) {
            sj.add(elem[i] + "");
        }
        return sj.toString();
    }
}