数据结构：顺序表的常用方法实现

@Override
public void add(int pos, int data) {
    // 1. pos 位置的判断 -> pos 不能为负的或 pos 不能隔空插元素
    checkPosOfAdd(pos);
    // 2. 如果这个数组是满的，则需要对数组进行扩容才能插入新元素
    isFulling();
    // 3. 先挪动元素，将最后面元素逐个往前挪
    // i >= pos 时元素才会往前移
    for (int i = usedSize - 1; i >= pos; i--) {
        elem[i + 1] = elem[i];
    }
    // 挪完将指定元素插入到位置中
    elem[pos] = data;
    usedSize++;
}

// 1. pos 位置的判断 -> pos 不能为负的或 pos 不能隔空插元素
public void checkPosOfAdd(int pos) {
    if (pos < 0 || pos > usedSize) {
        throw new PosException("pos 位置是" + pos);
    }
}

// 2. 如果这个数组是满的，则需要对数组进行扩容才能插入新元素
public void isFulling() {
    elem = Arrays.copyOf(elem, 2 * elem.length);
}

注意：如果数组已满且未扩容直接插入，会报越界异常。解决方案是在插入前判断是否已满，若满则扩容。

查找当前元素是否存在

/**
 * 查找当前元素是否存在
 * @param toFind
 * @return
 */
@Override
public boolean contains(int toFind) {
    for (int i = 0; i < usedSize; i++) {
        if (elem[i] == toFind) {
            return true;
        }
    }
    return false;
}

如果这里的元素是引用类型，需要通过 equals 进行比较。

查找当前元素的下标

/**
 * 查找当前元素的下标
 * @param toFind
 * @return
 */
@Override
public int indexOf(int toFind) {
    for (int i = 0; i < usedSize; i++) {
        if (elem[i] == toFind) {
            // 如果这里是引用数据类型需要用 equals 进行比较
            return i;
        }
    }
    return -1;
}

获取对应下标对应元素的数值

/**
 * 获取 pos 位置的值
 * @param pos
 * @return
 */
@Override
public int get(int pos) {
    // 1. 判断 pos 合法性
    checkPosGet(pos);
    // 2. pos 为空的异常处理
    if (isEmpty()) {
        throw new EmptyException("数组为空，无法获取元素");
    }
    return elem[pos];
}

// 1. 判断 pos 合法性
public void checkPosGet(int pos) {
    if (pos < 0 || pos >= usedSize) {
        throw new PosException("Pos 不合法，位置是：" + pos);
    }
}

// 2. pos 为空的异常处理 -> 此时 pos 正好符合>=usedSize(为 0) 的情况，算是 1 的一种。
public boolean isEmpty() {
    return usedSize == 0;
}

更新对应下标的元素值

/**
 * 更新 pos 位置的值为 value
 * @param pos
 * @param value
 */
@Override
public void set(int pos, int value) {
    // 1. 检查 pos 位置的合法性
    checkPosOfSet(pos);
    // 2. pos 为空的异常处理
    if (isEmpty()) {
        throw new EmptyException("顺序表为空");
    }
    elem[pos] = value;
}

public void checkPosOfSet(int pos) {
    if (pos < 0 || pos >= usedSize) {
        throw new PosException("Pos 位置不合法位置是：" + pos);
    }
}

获取顺序表的大小

/**
 * 获取顺序表的大小
 * @return
 */
@Override
public int size() {
    return this.usedSize;
}

删除指定元素

/**
 * 删除 toRemove 这个数字
 * 删除指定元素
 * @param toRemove
 */
@Override
public void remove(int toRemove) {
    // 首先，找到元素下标
    // 因为刚刚已经实现过通过元素寻找下标的方法了，现在只要调用这个方法即可找到对应元素的下标
    int index = indexOf(toRemove);
    // 然后，将这个位置前面的元素往后移动覆盖掉即可删除
    for (int i = index; i < usedSize - 1; i++) {
        elem[i] = elem[i + 1];
    }
    usedSize--;
}

释放内存

在源码中通常先将元素置为 null 之后，再将空间置为 0 进行释放。

/**
 * 清空顺序表，防止内存泄漏
 */
@Override
public void clear() {
    usedSize = 0;
}

示例中的数据都是 int 类型不是引用类型，所以如果需要释放内存，直接将其赋值为 0 即可。而对于引用类型由于他们有内存地址所以需要将它们置为 null 才能释放内存。