【难点】: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();
}
}