【Java】/* 顺序表 - 底层实现 */

【难点】：remove 和 removeAllKey 方法

一、IList

package bagone;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: tangyuxiu
 * Date: 2024-08-20
 * Time: 15:06
 */
public interface IList<E> {
    // 新增元素,默认在数组最后新增
    void add(E data);
    // 在 pos 位置新增元素
    void add(int pos, E data);

    // 判定是否包含某个元素
    boolean contains(E toFind);
    // 查找某个元素对应的位置
    int indexOf(E toFind);
    // 获取 pos 位置的元素
    E get(int pos);
    // 给 pos 位置的元素设为 value
    void set(int pos, E value);

    //删除第一次出现的关键字key
    boolean remove(E toRemove);
    //删除顺序表中所有的key
    void removeAllKey(E toRemove);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    void display();
}

二、MyArrayList

package bagone;

import java.util.Arrays;
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: tangyuxiu
 * Date: 2024-08-20
 * Time: 15:06
 */
public class MyArrayList<E> implements IList<E> {
    //① 如果实现的接口是泛型的，实现该接口的类也写成泛型的
    //② 泛型类中使用到的数组用Object[]类型

    /* 成员变量 */
    private Object[] elem;
    private int usedSize;//有效数据个数

    //③ 泛型类的构造方法的方法名后不要加<>

    /* 构造方法 */
    public MyArrayList() {//带参数
        this.elem = new Object[3];
    }

    public MyArrayList(int capacity) {//带参数
        this.elem =  new Object[capacity];
    }

    //④ 使用数组需要判断数组是否已满，使用节点需要判断head是否为null

    /* 判断顺序表是否已满 */
    private boolean isFull() {
        if(this.elem.length == this.usedSize) {
            return true;
        }
        return false;
    }

    /* 扩容 */
    private void newCapacity() {
        this.elem = Arrays.copyOf(this.elem, this.elem.length * 2);
    }

    /* 尾插 */
    @Override
    public void add(E data) {
        //1. 判断顺序表是否已满
        if (this.isFull()) {
            this.newCapacity();
        }
        //2. 尾插
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

    /* 判断add位置是否合法 */
    private boolean addIndexIsLegal(int pos) {
        if (pos < 0 || pos > this.usedSize) {
            return false;
        }
        return true;
    }

    /* 任意位置插入 */
    @Override
    public void add(int pos, E data) {
        //1. 判断pos位置是否合法
        if (!this.addIndexIsLegal(pos)) {
            return;
        }
        //2. 判断顺序表是否已满
        if (this.isFull()) {
            this.newCapacity();
        }
        //3. 在pos位置插入新元素
        for (int i = this.usedSize; i > pos; i--) {
            this.elem[i] = this.elem[i - 1];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

    /* 是否包含某元素 */
    @Override
    public boolean contains(E toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(toFind)) {
                return true;
            }
        }
        return false;
    }

    /* 某元素所在下标 */
    @Override
    public int indexOf(E toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(toFind)) {
                return i;
            }
        }
        return -1;
    }

    /* 判断get位置是否合法 */
    private boolean getIndexIsLegal(int pos) {
        if (pos < 0 || pos >= this.usedSize) {
            return false;
        }
        return true;
    }

    /* 得到某下标的元素 */
    @Override
    public E get(int pos) {
        //1. 判断pos位置是否合法
        if (!this.getIndexIsLegal(pos)) {
            return null;
        }
        //2. 获取
        return (E)this.elem[pos];
    }

    /* 替换某下标元素的值 */
    @Override
    public void set(int pos, E value) {
        //1. 判断pos位置是否合法
        if (!this.getIndexIsLegal(pos)) {
            return;
        }
        //2. 替换
        this.elem[pos] = value;
    }

    /* 删除第一次出现的关键字key */
    @Override
    public boolean remove(E toRemove) {
        int cur = this.indexOf(toRemove);
        if (cur != -1) {
            for (int i = cur; i < this.usedSize - 1; i++) {
                this.elem[i] = this.elem[i + 1];
            }
            this.usedSize--;
            return true;
        }
        return false;
    }

    /* 删除顺序表中所有的key */
    @Override
    public void removeAllKey(E toRemove) {
        Object[] newElem = new Object[this.usedSize];
        int j = 0;//新顺序表的有效数据个数
        for (int i = 0; i < this.usedSize; i++) {
            if (!this.elem[i].equals(toRemove)) {
                newElem[j] = this.elem[i];
                j++;
            }
        }
        this.elem = newElem;
        this.usedSize = j;
    }

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

    /* 清空顺序表 */
    @Override
    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        this.elem = Arrays.copyOf(this.elem, 0);
        this.usedSize = 0;
    }

    /* 打印顺序表 */
    @Override
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }
}