Java中的顺序表(ArrayList)的简单实现

ArrayList：

构成： 由数组+size组成。
继承结构： ArrayList -> List ->Collection -> Iterable

---

简单实现：

文件：

---

MyList：

package ArrayList;

/*
自定义的线性表（以接口形式体现）
1. 元素类型 Long
   1）int 下标   long 元素
   2）包装类：体现对象的形式而不是基本类型
2. 准备线性表的规定
3. 有元素的位置: != null
   没有元素的位置: == null
 */

public interface MyList {
    /**
     * 返回线性表中的元素个数
     *
     * @return
     */
    int size();

    /**
     * 将 e 尾插到线性表中，一定返回 true
     *
     * @param e
     * @return
     */
    boolean add(Long e);

    /**
     * 将 e 插入到线性表的 index 位置，从 [index, size()) 向后移
     * index 的合法下标 [0, size()]
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     *
     * @param index
     * @param e
     */
    void add(int index, Long e);

    /**
     * 删除 index 位置的元素
     * index 的合法下标：[0, size())
     * 如果下标不合法：抛出一个 ArrayIndexOutOfBoundsException
     *
     * @param index
     * @return 从线性表中删除掉的元素
     */
    Long remove(int index);

    /**
     * 从前到后，删除第一个遇到的 e（ equals() == true）
     *
     * @param e
     * @return 删除成功：true，没有该元素：false
     */
    boolean remove(Long e);

    /**
     * 直接返回 index 位置的元素
     * index: [0, size())
     *
     * @param index
     * @return
     */
    Long get(int index);

    /**
     * 使用 e 替换 index 位置的元素
     *
     * @param index [0, size())
     * @param e
     * @return 原来 index 位置的元素
     */
    Long set(int index, Long e);

    /**
     * 返回第一次遇到 e 的下标（equals() == true）
     *
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int indexOf(Long e);

    /**
     * 从后往前，返回第一次遇到 e 的下标（equals() == true）
     *
     * @param e
     * @return 如果没有找到，返回 -1
     */
    int lastIndexOf(Long e);

    /**
     * 线性表中是否包含 e（equals）
     *
     * @param e
     * @return
     */
    boolean contains(Long e);

    /**
     * 清空线性表
     */
    void clear();

    /**
     * 判断线性表是否是空的（empty） 等价于一个元素都没有
     *
     * @return
     */
    boolean isEmpty();
}

---

ArrayList:

package ArrayList;

class MyArrayList implements MyList {

    private Long[] arr;
    private int size;

    //无参构造
    public MyArrayList() {
        this.arr = new Long[32];
        this.size = 0;
    }

    //带参构造 用来自己规定顺序表的初始大小
    public MyArrayList(int capacity) {
        this.arr = new Long[capacity];
        this.size = 0;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean add(Long e) {
        arr[size] = e;
        size++;
        return true;
    }

    @Override
    public void add(int index, Long e) {
        //检测下标是否非法
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("下标不合法!");
        }
        for (int i = size - 1; i >= index; i--) {
            arr[i + 1] = arr[i];
        }
        arr[index] = e;
        size++;
    }

    @Override
    public Long remove(int index) {
        //检测下标是否非法
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("下标不合法!");
        }
        //保存要删除的元素用于返回
        Long ret = arr[index];
        for (int i = index; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[size - 1] = null;
        size--;
        return ret;
    }

    @Override
    public boolean remove(Long e) {
        for (int i = 0; i < size; i++) {
            if (arr[i].equals(e)) {
                remove(i);
                return true;
            }
        }
        //若未找到 返回false
        return false;
    }

    @Override
    public Long get(int index) {
        //检测下标是否非法
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("下标不合法!");
        }
        return arr[index];
    }

    @Override
    public Long set(int index, Long e) {
        //检测下标是否非法
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("下标不合法!");
        }
        //保存原来的元素用于返回
        Long ret = arr[index];
        arr[index] = e;
        return ret;
    }

    @Override
    public int indexOf(Long e) {
        for (int i = 0; i < size; i++) {
            if (arr[i].equals(e)) {
                return i;
            }
        }
        //未找到返回-1；
        return -1;
    }

    @Override
    public int lastIndexOf(Long e) {
        for (int i = size - 1; i >= 0; i--) {
            if (arr[i].equals(e)) {
                return i;
            }
        }
        //未找到返回-1；
        return -1;
    }

    @Override
    public boolean contains(Long e) {
        for (int i = 0; i < size; i++) {
            if (arr[i].equals(e)) {
                return true;
            }
        }
        //未找到返回false
        return false;
    }

    @Override
    public void clear() {
        //全部置为null
        for (int i = 0; i < size; i++) {
            arr[i] = null;
        }
        size = 0;
    }

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