java简单实现顺序表

顺序表是什么？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数
据的增删查改。

顺序表一般可以分为：

静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。
静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用.
相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.

简单看下代码

public class SeqList {
    int[] data = new int[10];
    private  int size = 0;
    //打印
    public void display(){
        for(int i = 0; i < size; i++){
            if(i == 0){
                System.out.print("[");
            }
            if(i < size - 1){
                System.out.print(data[i]+ ",");
            }
            else{
                System.out.print(data[i] +"]");
            }
        }
        System.out.println();
    }
//添加元素
    public void add(int pos, int elem) {
              if(size >= data.length){
                  realloc();
              }
              if (pos < 0 || pos > data.length) {
                  return;
              }
              if (pos == size) {
                  data[pos] = elem;
                  size++;
              } else {
                  for (int i = size - 1; i >= pos; i--) {
                      data[i + 1] = data[i];
                  }
                  data[pos] = elem;
                  size++;
              }
          }
          //增容
          public void realloc(){
        int[] arr = new int[data.length * 2];
        for(int i = 0; i < data.length; i++){
            arr[i] = data[i];
        }
        this.data = arr;
       }
       //查找某个元素位置
       public int search(int toFind) {
        for(int i = 0; i < size; i++){
            if(data[i] == toFind){
                return i;
            }
        }
        return -1;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        int p = search(toFind);
        if(p != -1) {
            return true;
        }
        return false;
    }
    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if(pos > 0 && pos < size){
            return data[pos];
        }
        return -1;
    }
    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        data[pos] = value;
    }
    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        int num = search(toRemove);
        if(num == -1){
            return;
        }
        for(;num < size - 1; num++){
            data[num] = data[num + 1];
        }
        size--;
        System.out.println("删除成功");
    }
    //获取顺序表长度
    public int size() {
        return size;
    }
     清空顺序表
    public void clear() {
        data = new int[10];
        size = 0;
        System.out.println("清空完毕");
    }
    public static void main(String[] args) {
        //在另一个实验类中检验是否满足要求;
    }
}

检验代码是否满足要求可在另一个类中

public class Test {
    public static void main(String[] args) {
        SeqList List1 = new SeqList();
        //检验
        List1.add(0,1);
        List1.add(1,2);
        List1.add(2,3);
        List1.add(3,5);
        List1.add(2,1);
        List1.add(5,1);
        List1.add(6,100);
        List1.add(7,60);
        List1.add(8,9);
        List1.add(9,10);
        List1.add(3,2);
        List1.display();
        System.out.println(List1.search(100));
        System.out.println(List1.contains(40));
        System.out.println(List1.size());
        System.out.println(List1.getPos(5));
        List1.setPos(5,1001);
        List1.remove(2);
        List1.display();
    }
}

这个顺序表就是简单的动态存储，空间不够了自动扩容为原数组的2倍。
看一下注释就可以明白了。