动态数组（Array）

动态数组的概念

我们可以理解为动态数组就是在普通数组上增加了一个可以根据元素的个数动态调整数组大小的功能。在Java中提供的数组一般都是静态数组int[]char[]long[]（定义之后没法改变长度）这时候就需要我们自己定义一个类，拓展基础数组的功能就为动态数组。动态数组相对于一般数组的优势是可以灵活地添加或删除元素。而一般数组则受限于固定的内存空间。只能有限的添加元素。

public class Array {
    private int[] data;
    //存放元素仍是整型数组；
    private int size;
    //表是动态数组中已经存储的元素个数； 
}

size：表示当前动态数组中实际存储的元素个数，下一个元素添加时候的索引。

int[]data；data.length表示此时数组最大容纳大元素个数。当size==data.length时就是表明这个数组容量已满需要扩容处理。

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

元素的增加操作

add(添加一个新元素）

    public void add(int val){
        data[size]=val;
        size++;
        if (size==data.length){
//如果数组容量已满
            grow();
        }
    }

add（int index，int val）在index位置插入新元素val 

 public void adds(int index,int val){
        if (index<0||index>size){
            System.err.println("add index");
            return;
        }
        for (int i = size-1; i <index ; i++) {
            data[i+1]=data[i];
        }
        data[index]=val;
        size++;
        //判断数组是否已满
        if (size==data.length){
            grow();
        }
    }

 元素的删除操作

remove（int index）：删除指定index位置的元素。

remove（1）：删除索引为1的元素

此时需要把index之后所有元素向前移动一个单位，先从index+1开始向前移动，这样就可以覆盖的就是index位置的元素。

   public int remove(int index){
        //先判断索引的合法
        if (index<0||index>=size){
            return -1;
        }
        int Val=data[index];
        for (int i = index; i <size-1; i++) {
            data[i]=data[i+1];
        }
        size--;
//        return size;
        return Val;
    }

删除数组中所有值为val的元素 

当出现连续的val值，再删除remove（index）之后，任然要判断当前i是否还是待删除元素。这时候我们就要用while循环来判断。

 

    public int removeBy(int val){
        for (int i = 0; i <size ; i++) {
            while (data[i]==val){
             remove(i);
                }
            }
            size--;
    return val;
    }

 元素查询的操作

    //查询动态数组值为vale元素的索引
    public int getByVale(int val){
        for (int i = 0; i < size; i++) {
            if (data[i]==val){
                return i;
            }}
            //如果没找到val值
            return -1;
    }
    public boolean contains(int val){
        int index=getByVale(val);
        return index!=-1;
    }
    //查询索引为index的值并返回更改前的值
    public int get(int index){
        if (index<0||index>=size){
            System.err.println("get index illegal");
            return -1;
        }
        return data[index];

 元素的更改操作

    //更改数组中为索引index的位置为val的值
    public int set(int index ,int newVal){
        if (index<0||index>=size){
            System.err.println("set index.illegal!");
            return -1;
        }
     int oldVal=data[index];

data[index]=newVal;
return oldVal;
    }
    public boolean setValue(int oldVal,int newVal){
        int index=getByVale(oldVal);
        if (index!=-1){
            data[index]=newVal;
            return true;
        }
        return false;
    }

动态数组的完整代码

package seqlist;


import java.util.Arrays;

public class Array {
    private int[] data;
    //存放元素仍是整型数组；
    private int size;
    //表是动态书组中已经存储的元素个数；
    public  Array(){
        this(10);
    }
    public Array( int intCap){

        this.data=new int[intCap];
    }
    //增加一个新的元素
    public void add(int val){
        data[size]=val;
        size++;
        if (size==data.length){
            grow();
        }
    }
    //在数组index的位置插入一个值为val的元素
    public void adds(int index,int val){
        if (index<0||index>size){
            System.err.println("add index");
            return;
        }
        for (int i = size-1; i <index ; i++) {
            data[i+1]=data[i];
        }
        data[index]=val;
        size++;
        //判断数组是否已满
        if (size==data.length){
            grow();
        }
    }
    //查询动态数组值为vale元素的索引
    public int getByVale(int val){
        for (int i = 0; i < size; i++) {
            if (data[i]==val){
                return i;
            }}
            //如果没找到val值
            return -1;
    }
    public boolean contains(int val){
        int index=getByVale(val);
        return index!=-1;
    }
    //查询索引为index的值并返回更改前的值
    public int get(int index){
        if (index<0||index>=size){
            System.err.println("get index illegal");
            return -1;
        }
        return data[index];
    }
    //更改数组中为索引index的位置为val的值
    public int set(int index ,int newVal){
        if (index<0||index>=size){
            System.err.println("set index.illegal!");
            return -1;
        }
     int oldVal=data[index];

data[index]=newVal;
return oldVal;
    }
    public boolean setValue(int oldVal,int newVal){
        int index=getByVale(oldVal);
        if (index!=-1){
            data[index]=newVal;
            return true;
        }
        return false;
    }
    //删除索引为index对应的元素，并返回删除的值
    public int remove(int index){
        //先判断索引的合法
        if (index<0||index>=size){
            return -1;
        }
        int Val=data[index];
        for (int i = index; i <size-1; i++) {
            data[i]=data[i+1];
        }
        size--;
//        return size;
        return Val;
    }
    //删除数组中所有为val的值
    public int removeBy(int val){
        for (int i = 0; i <size ; i++) {
            while (data[i]==val){
             remove(i);
                }
            }
            size--;
    return val;
    }
    //toString打印数组
    public String toString(){
        String ret="[";
        for (int i = 0; i < size; i++) {
            ret+=data[i];
            if (i!=size-1){
                ret+=",";
            }
        }
        ret+="]";
        return ret;

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