动态数组（增删改查）

一.包的创建

1.创建包

包名称使用全小写，多个单词使用下划线分隔

表示当前的MyArray类是在seqlist这个包下。
包（文件夹）最大的意义在于类可以重名。
文件的全名称：路径+文件名称+文件后缀
类的全名称：包名.类名 （seqlist.MyArray)

2.包的访问权限

就是权限啥也没写，默认就是包访问权限
对于包访问权限来说，只有当前包的内部可见，子包，子文件夹都不可见。

（对于不同文件夹有多个重名的类，这个时候使用import导入类，import只能导入某个包中的某个类，不能直接导入一个包，格式为：import 包名.类名;）

import java.util.Arrays;

二.线性表

线性表的定义

线性表是n个具有相同特性的数据元素的有限序列，是一种在实际中广泛使用的数据结构，在逻辑上是线性结构，在物理上的结构不一定是线性的，常见的线性表有：顺序表，链表，栈，队列，字符转…
顺序表：

逻辑连续，物理不连续：

三.动态数组

1.动态数组的定义

动态数组就是在普通数组上，增加了一个可以根据元素的个数动态调整数组大小的功能。

Java中提供的数组都是静态数组：int[] char[] long[] 定义之后没办法改变长度。
所以需要我们自己写一个类，拓展基础数组的功能。

        private int[] data;
        //表示当前动态数组已经存储元素个数
        private int size;

size这个属性永远都是当前有效元素的下一个位置的索引，下一次再存储新元素时，直接使用size对应的索引即可。

data[size] = 20;
size++;

2.扩充

当size == data.length的时候需要使数组扩充，确保size是有效元素的下一个位置的索引。

private void grow() {
            //copy方法返回扩容后的新数组
            this.data = Arrays.copyOf(data,data.length * 2);
    }

3.增加

（1）向当前数组中添加元素 -> 添加到数组末尾

public void add(int val){
            data[size] = val;
            size++;
            if(size == data.length){
                grow();
            }
        }

（2）向当前动态数组中index索引位置添加一个新的元素，新元素插入后的索引为index。

public void add(int index,int val){
            //先判断边界条件，index是不是一个非法的索引
        //index = 0在头部插入，index = size在尾部插入
        if(index < 0 || index > size){
            System.err.println("add index illegal!");
            return;
        }
        //从当前最后一个又笑元素开始搬移，把index空出来
        for (int i = size - 1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = val;
        size++;
        if(size == data.length){
            grow();
        }
    }

4.查询

（1）查询当前动态数组中第一个值为val的元素索引。

public int getByValue(int val){
        for (int i = 0; i < size; i++) {
            if(data[i] == val){
                return i;
            }
        }
        return -1;
    }

（2）查询当前动态数组中是否包含值为val的元素，若存在返回true，否则返回false。

public boolean contains(int val){
        return getByValue(val) != -1;
    }

（3）查询当前动态数组中索引为index的元素值。

 public int get(int index){
        if(index < 0 || index >= size){
            System.err.println("get index illagal!!");
            return -1;
        }
        return data[index];
    }

5.修改

（1）修改当前动态数组中索引为index位置的元素值为newVal，返回修改前的值。

public int set(int index,int newVal){
        if(index < 0 || index >= size){
            return -1;
        }
        int oldVal = data[index];
        data[index] = newVal;
        return oldVal;
    }

（2）修改第一个值为oldVal的元素，更改为新的值newVal，返回是否修改成功。

public boolean setVal(int oldVal,int newVal){
        int index = getByValue(oldVal);
        if(index != -1){
            data[index] = newVal;
            return true;
        }
        System.err.println("old value is not exist!!");
        return false;
    }

6.删除

（1）:删除索引为index对应的元素，返回删除前的元素。

public int removeIndex(int index){
        if(index < 0 || index >= size){
            System.err.println("remove index illega!");
            return -1;
        }
        int oldVal = data[index];
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i+1];
        }
        size--;
        return oldVal;
    }

（2）删除数组头元素

public int removeFirst(){
        return removeIndex(0);
    }

（3）删除尾部元素

public int removeLast(){
        return removeIndex(size - 1);
    }

（4）删除第一个值为val的元素返回是否删除成功

public boolean removeValueOnce(int val){
        for (int i = 0; i < size; i++) {
            if(data[i] == val){
                removeIndex(i);
                return true;
            }
        }
        return false;