Java顺序表

顺序表：

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

顺序表一般可以分为：
1.静态顺序表：使用定长数组存储。
2.动态顺序表：使用动态开辟的数组存储。

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

```java
 public class SeqList {     
 // 打印顺序表     
 public void display() {    }     
 // 在 pos 位置新增元素     
 public void add(int pos, int data) {  }     
 // 判定是否包含某个元素     
 public boolean contains(int toFind) { return true; }     
 // 查找某个元素对应的位置     
 public int search(int toFind) { return -1; }     
 // 获取 pos 位置的元素     
 public int getPos(int pos) { return -1; }     
 // 给 pos 位置的元素设为 value     
 public void setPos(int pos, int value) {    }     
 //删除第一次出现的关键字key     
 public void remove(int toRemove) {    }    
 // 获取顺序表长度     
 public int size() { return 0; }     
 // 清空顺序表     public void clear() {    } 
 }

具体代码实现：

public class Sequence {
    private int[] data=new int[10];   //我们不希望用户直接使用，通过方法
    private int num=0;
//展示
    public void display(){
        System.out.print("[");
        for(int i=0;i<this.num;i++){
            if(i !=num-1) {
                System.out.print(data[i]+",");
            }
            else System.out.print(data[i]);
        }
        System.out.print("]");
    }
//添加
    public void add(int place,int aim){
        if(place>this.num && place<0){
            System.out.println("Error");
            return;
        }
        if(this.num>10){
            relloc();
        }
        if(num==place) {
            this.data[place] = aim;
            num++;
        }
        else {
            for (int i = num-1; i >=place; i--) {
                this.data[i+1] = this.data[i];
            }
            this.data[place] = aim;
            num++;
        }
    }
    private void relloc(){
        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 aim){
    for(int i=0;i<this.num;i++){
        if(aim==this.data[i]){
            return i;
        }
    }
    return -1;
}
// 判定是否包含某个元素
    public boolean include(int aim){
        for(int i=0;i<this.num;i++){
            if(aim==this.data[i]){
                return true;
            }
        }
        return false;
    }
    // 获取 pos 位置的元素
    public int src(int pos){
        if(pos>this.num-1){
            System.out.println("place is missing");
            return -1;
        }
        else {
            return this.data[pos];
        }
    }
    // 给 pos 位置的元素设为 value
    public void setValue(int pos,int aim) {
        if (pos > this.num - 1) {
            System.out.println("place is missing");
            return;
        } else {
        this.data[pos]=aim;
        }
    }
    //删除第一次出现的关键字key
    public void del(int aim){
        int place = search(aim);
        if(place == -1){
            System.out.println("元素找不到");
            return;
        }
        for(;place < num - 1; place++){
            data[place] = data[place + 1];
        }
        num--;
        System.out.println("删除成功");
    }
    //获取顺序表长度
    public int getLength(){

        return num;
    }
     清空顺序表
    public void clear(){
        data = new int[10];
        this.num=0;
        System.out.println("清空完毕");
    }

}

注意，顺序表虽然是用实现的，但是要区别一般数组，它有一定的结构要求，它的顺序是有要求的，我们对于顺序表的修改必须符合顺序。