Java数据结构之数组的增删改查

1.数组元素的读取（时间复杂度O（1））

对于数组来说，读取元素是最简单的操作。因为数组在内存中是顺序存储的，只需要给出一个下标，就可以读取到对应得的数组元素

int [] array = new int[]{1,9,6,3,4,8};
//读出下标为3的数组元素
System.out.println(array[3]);

2.数组元素的更新（时间复杂度O（1））

对于数组来说，更新元素也是非常简单的操作。直接利用数组下标就可以把新值赋值给该元素

 int [] array = new int[]{1,9,6,3,4,8};
        //读出下标为3的数组元素
        System.out.println("未修改前"+array[3]);
        System.out.println("未修改前数组");
        for (int i = 0; i < array.length; i++) {
            System.out.print("["+array[i]+"]");
        }
        //换行
        System.out.println();
        //把新值 10086 赋值给数组元素下标为3的元素
        array[3]=10086;
        System.out.println("修改之后"+array[3]);
        System.out.println("修改之后数组");
        for (int i = 0; i < array.length; i++) {
            System.out.print("["+array[i]+"]");
        }

3.数组元素的插入（时间复杂度O（n））

3.1尾部插入

尾部插入相对简单，直接把插入的元素放入尾部的空闲位置即可

        //准备一个数组
        //下面这种写法是把数组直接写死在内存中，无法再插入元素
        int [] array = new int[]{1,9,6,3,4,8};
        //再次准备一个未满的数组，数组长度为8
        int[] array2 = new int[8];
        array2[0]=1;
        array2[1]=9;
        array2[2]=6;
        //输出原始数组，此时数组有三个元素
        System.out.println("原始数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.print("["+array2[i]+"]");
        }
        //换行
        System.out.println();
        //进行插入，往第四个元素位置插入元素
        array2[3]=8;
        //输出插入元素后数组，此时数组有四个元素
        System.out.println("插入元素后数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.print("["+array2[i]+"]");
        }

3.2中间插入

中间插入就比较麻烦，由于每个数组元素都有其固定下标，所以不得不把插入位置及以后的元素全部后移
package 数组;

/**

• @author:MZH
• @QQ:2563548305
• @Date:2022/8/31 17:39
  */

/**

• 中间插入就比较麻烦，由于每个数组元素都有其固定下标，所以不得不把插入位置及以后的元素全部后移
  */
  public class MyArray2 {
  //准备数组
  private int[] array;
  //数组的实际长度，也就是数组里面实际有多少个元素
  private int size;

  /**
  *

  • pram capacity 初始化数组容量
    */

  public MyArray2(int capacity){
  this.array = new int[capacity];
  size = 0;
  }

  /**

  • @param element 插入的元素
  • @param index 插入的位置
    */
    public void insert(int element,int index) throws Exception{
    //判断插入的位置是否超出范围
    if (index<0||index>size){
    throw new Exception(“超出数组实际范围”);
    }
    //从右往左循环，移动元素
    for (int i=size-1;i>=index;i–){
    array[i+1]=array[i];
    }
    //放入新元素
    array[index]=element;
    //数组的实际长度加一
    size++;
    }
    //打印数组
    public void print(){
    for (int i = 0; i < size; i++) {
    System.out.print(“[”+array[i]+“]”);
    }
    System.out.println();
    }

  public static void main(String[] args) throws Exception{
  MyArray2 myArray2 = new MyArray2(6);
  myArray2.insert(10,0);
  myArray2.insert(18,0);
  myArray2.insert(15,0);
  myArray2.insert(17,0);
  myArray2.insert(99,1);
  myArray2.print();
  }
  }

3.3超范围插入

假如现在有一个长度为6的数组，想插入第7个元素，怎么办？
扩容！
因为数组一旦创建，长度就确定了，无法改变，所以我们可以准备一个新的数组，长度是原来数组的2倍，再把原来数组中的元素复制到新的数组中，这样就实现了扩容。

package 数组;

/**
 * @author:MZH
 * @QQ:2563548305
 * @Date:2022/8/31 17:39
 */

/**
 * 中间插入就比较麻烦，由于每个数组元素都有其固定下标，所以不得不把插入位置及以后的元素全部后移
 */
public class MyArray2 {
    //准备数组
    private int[] array;
    //数组的实际长度，也就是数组里面实际有多少个元素
    private int size;

    /**
     *
     * pram capacity 初始化数组容量
     */

    public MyArray2(int capacity){
         this.array = new int[capacity];
         size = 0;
     }

    /**
     * @param element 插入的元素
     * @param index 插入的位置
     */
    public void insert(int element,int index) throws Exception{
        //判断插入的位置是否超出范围
        if (index<0||index>size){
            throw new Exception("超出数组实际范围");
        }
        if (size>=array.length){
            reSize();
        }
        //从右往左循环，移动元素
        for (int i=size-1;i>=index;i--){
            array[i+1]=array[i];
        }
        //放入新元素
        array[index]=element;
        //数组的实际长度加一
        size++;
    }

    /**
     * 数组扩容
     */
    public void reSize(){
        //准备大一点的数组
        int[] newArray = new int[array.length * 2];
        //把旧的数组复制到新的数组
        System.arraycopy(array,0,newArray,0,array.length);
        array=newArray;
    }

    //打印数组
    public void print(){
        for (int i = 0; i < size; i++) {
            System.out.print("["+array[i]+"]");
        }
        System.out.println();
    }

    public static void main(String[] args) throws Exception{
        MyArray2 myArray2 = new MyArray2(6);
        myArray2.insert(10,0);
        myArray2.insert(18,0);
        myArray2.insert(15,0);
        myArray2.insert(17,0);
        myArray2.insert(99,1);
        myArray2.insert(78,1);
        myArray2.insert(80,1);
        myArray2.print();

    }
}

4.数组元素的删除（时间复杂度O（n））

数组的删除不涉及扩容，所以较为简单

/**
     * 
     * @param index 删除的位置
     * @throws Exception
     */
     public  void delete(int index)throws  Exception{
         //判断删除的位置是否超出范围
         if (index<0||index>=size){
             throw new Exception("超出数组实际范围");
         }
         //从左往右循环，元素左移
         for (int i = index;i<=size-1;i++){
             array[i]=array[i+1];
         }
         size--;
     }