目录

1.属性设置

2.顺序表的基本方法

3.顺序表的基本方法的实现

1.display方法

2.add方法

1.isFull方法

2.默认在数组最后新增的add方法 

3.checkPosInAdd方法

4.MyArrayListIndexOutofException类

5.在指定位置添加的add方法 

3.contains方法

 4.IndexOf方法

5.get方法

6.set方法

7.remove方法

8.size方法

9.clear方法

4.测试代码

1.属性设置

import java.util.ArrayList;
import java.util.Arrays;

public class MyArraylist {
    public int[]arr;
    public int usedSize;//有效数据
    private static final int DEFAULT_SIZE=4;//默认值
    public MyArraylist() {
        this.arr=new int[DEFAULT_SIZE];
    }

顺序表的底层是一个数组，故定义一个数组，并用usedSize来记录有效数据。我还设置了一个默认值为数组开辟了一个默认的空间，这个大小是固定的。但后续可以扩容来扩大数组的容量。

2.顺序表的基本方法

// 打印顺序表
  public void display() {  }
   // 新增元素,默认在数组最后新增
  public void add(int data) { }
  // 在 pos 位置新增元素
  public void add(int pos, int data){   } 
 // 判定是否包含某个元素
  public boolean contains(int key) {  }
  // 查找某个元素对应的位置
  public int indexOf(int key) { }
  // 获取 pos 位置的元素
  public int get(int pos) { }
  // 给 pos 位置的元素设为 value
  public void set(int pos, int value) {  }
  //删除第一次出现的关键字key
  public void remove(int key) {  }
  // 获取顺序表长度
  public int size() {  }
  // 清空顺序表
  public void clear() {  }

3.顺序表的基本方法的实现

1.display方法

public void display() {
    for (int i = 0; i  
遍历整个顺序表并打印每一个有效数据
 
2.add方法 
1.isFull方法 
//判断数组是否满了
        private boolean isFull(){
          return this.usedSize==this.arr.length;

        }
        private boolean checkPosInAdd(int pos){
        return pos>this.usedSize||pos<0;
        }
 
2.默认在数组最后新增的add方法  
// 新增元素,默认在数组最后新增
        public void add(int data) {
        if(isFull()) {

            this.arr = Arrays.copyOf(this.arr, 2 * this.arr.length);
        }
            this.arr[usedSize] = data;
            this.usedSize++;

        }
 
这里需要考虑增加数据会导致数组空间不足，故这里需要进行一个判断，如果空间不足，就得扩容。
 
3.checkPosInAdd方法 
//判断pos的位置合不合法
        private boolean checkPosInAdd(int pos){
        return pos>this.usedSize||pos<0;
        }
 
4.MyArrayListIndexOutofException类 
public class MyArraylistIndexOutOfException extends RuntimeException{

    public MyArraylistIndexOutOfException() {
    }

    public MyArraylistIndexOutOfException(String message) {
        super(message);
    }
}
 
自定义的一个异常，用于之后的add方法若pos位置不合法，则会抛出异常
 
5.在指定位置添加的add方法  
// 在 pos 位置新增元素
        public void add(int pos, int data) {
            if (checkPosInAdd(pos)) {

                throw new MyArraylistIndexOutOfException("pos位置不合法");
            } else {
                if (isFull()) {

                    this.arr = Arrays.copyOf(this.arr, 2 * this.arr.length);
                }
                for (int i = usedSize-1; i > pos-1; i--) {
                    this.arr[i + 1] = this.arr[i];

                }
                this.arr[pos] = data;
                this.usedSize++;
            }
        }
 
这个add方法与上面的add方法发生了重载，在数据结构当中，每次存储元素的时候，需要一个前驱信息 ，故不能跨越式添加。用于自己内部的函数设置为private。
 
这里的扩容是new了一个新的数组，拷贝了原来的数组，并且空间扩大到原来的两倍。
 
在指定位置添加元素采用的逻辑是从最后一个开始，前一个覆盖后一个。最后将指定元素指定为自己设置的值。
 
3.contains方法 
  //判断是否包含某个元素
   public boolean contains(int key) {
       for (int i = 0; i  
 4.IndexOf方法 
// 查找某个元素对应的位置
        public int indexOf(int key) {
            for (int i = 0; i  
这里如果找不到元素就会返回一个-1
 
5.get方法 
//判断pos的合法性
       private boolean checkPosInGet(int pos){
    return pos>=this.usedSize||pos<0;
}
    // 获取 pos 位置的元素
        public int get(int pos) {
            if (checkPosInGet(pos)) {

                throw new MyArraylistIndexOutOfException("pos位置不合法");
            }
            return this.arr[pos];
   }
 
        这里面的checkPosInGet方法和前面的checkPosInAdd方法有一个区别，那就是一个是pos>=this.usedSize.一个取不到等号。因为不可以获得usedSize下标的值，因为usedSize下标对应的值是无效的，但可以在usedSize下标添加值。
 
6.set方法 
/ 给 pos 位置的元素设为 value
        public void set(int pos, int value) {
            if (checkPosInGet(pos)) {

                throw new MyArraylistIndexOutOfException("pos位置不合法");
            }
            this.arr[pos]=value;
        }
 
set方法和get类似,不可以给无效的值设值。
 
7.remove方法 
//判断顺序表是否为空
    private boolean isEmpty(){
        return this.usedSize==0;

    }
    //删除第一次出现的关键字key
        public void remove(int key) {
        if(isEmpty()){
            throw new MyArrayListEmptyException("顺序表为空，不能删除");
        }
            for (int i = 0; i  
 
public class MyArrayListEmptyException extends RuntimeException{
    public MyArrayListEmptyException() {
    }

    public MyArrayListEmptyException(String message) {
        super(message);
    }
}
 
在删除元素的时候，需要判断顺序表是否为空，若为空，也抛出一个异常，并且还有可能找不到。
 
删除的逻辑采用覆盖，后一个覆盖前一个，从而删除元素。
 
8.size方法 
// 获取顺序表长度
        public int size() {
       return this.usedSize;
   }
 
9.clear方法 
// 清空顺序表
        public void clear() {
//            for (int i = 0; i  
这里是不需要把每个值都设置为0的，因为打印的时候是依靠有效数据打印的，只要有效数据为0，那么打印出来的数据就是空的。而如果要添加也会覆盖之前的值，所以不需要将每个值都设置为0.
 
4.测试代码 
public class TestDemo {
    public static void main(String[] args) {
        MyArraylist myArraylist = new MyArraylist();
        myArraylist.add(1);
        myArraylist.add(1);
        myArraylist.add(1);
        myArraylist.display();
        myArraylist.add(2,22);
        myArraylist.add(0,22);
        myArraylist.add(5,22);

        myArraylist.display();
        myArraylist.remove(22);
        myArraylist.display();
        System.out.println(myArraylist.contains(22));
        System.out.println(myArraylist.get(2));
        System.out.println(myArraylist.indexOf(22));
        System.out.println(myArraylist.size());
        myArraylist.set(1,2);
        myArraylist.display();
        myArraylist.clear();
        myArraylist.display();

    }
}