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 <usedSize ; i++) {
        System.out.print(this.arr[i]+" ");
    }
    System.out.println();
}

遍历整个顺序表并打印每一个有效数据

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 <this.usedSize ; i++) {
           if(this.arr[i]==key){
               return true;
           }

       }
       return false;
   }

?4.IndexOf方法

// 查找某个元素对应的位置
        public int indexOf(int key) {
            for (int i = 0; i <this.usedSize ; i++) {
                if(this.arr[i]==key){
                    return i;
                }

            }
            return -1;
   }

这里如果找不到元素就会返回一个-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 <this.usedSize ; i++) {
                if(this.arr[i]==key){
                    for (int j = i; j <this.usedSize-1 ; j++) {
                        this.arr[j]=this.arr[j+1];
                    }
                    this.usedSize--;
                    return;
                }

            }
            System.out.println("找不到");
        }

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 <this.usedSize ; i++) {
//                this.arr[i]=0;
//            }
            this.usedSize=0;
        }
}

这里是不需要把每个值都设置为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();

    }
}