动态数组的知识

一、数组定义

1.需要一段连续空间

2.有下标

3.数组定义后长度不可变，数组满了之后不可再存储数据

因此可基于数组作为底层，构建一个动态数组类，用类创建的对象作为数组来操作数据。

二、动态数组类

1.属性

        底层结构：数组

        设定下标

        设定容量

2.方法

        初始化

        add：考虑底层数组是否存满

        get：考虑下标是否越界，返回对应位置的数

        remove：考虑下标是否越界，返回数据并删除数据，后置数据前移

3.代码

```java

package name;

// 字符串类型动态数组
public class MyArray{

   String[] values;
   int size;
   int length;

   // 构造方法 初始化
   // 构造方法是创建对象时调用
   // 1.方法名与类名相同
   // 2.没有返回值结构
   public MyArray(int initLength){
      if(initLength < 2){
         throw new RuntimeException ("数组长度不能小于0");// 报错
      }
      values = new String[initLength];
      size = 0;
      length = initLength;

   }

   public void addValue(String e){
      // 存储之前判断是否需要扩容
      if(size == length){
         int oldLength = length;
         int newLength = oldLength + (oldLength >> 1);// 1.5倍  1111>>0111
         // 根据计算的新长度 创建一个新的空字符串数组
         String[] newValues = new String[newLength];
         // 将原来的数组中的值拷贝到新的数组中
         for(int i = 0; i < oldLength; i++){
            newValues[i] = values[i];
         }
         // 将新的数组名赋值给原来的数组名
         values = newValues;
         // 更新长度
         length = newLength;
         System.out.println ("扩容：" + length);
      }
      values[size] = e;
      size++;
   }

   public String get(int index){
      if(index < 0 || index >= size){
         throw new RuntimeException ("下标越界");
      }
      System.out.println ("get数据： " + index + " - " + values[index]);
      return values[index];
   }

   public String remove(int index){
      if(index < 0 || index >= size){
         throw new RuntimeException ("下标越界");
      }
      // 取出需要被删除的数据
      String oldValue = values[index];
      // 循环将后面的数据往前移动一位 补上空位
      for(int i = index; i < size - 1; i++){
         values[i] = values[i + 1];
      }
      size--;
      return oldValue;
   }

   // 根据指定数据删除 - 可能会删除多个
   public int remove(String value){
      int count = 0;// 被删除的个数
      for(int i = 0; i < size; i++){
         if(values[i].equals (value)){
            remove (i);
            count++;
         }
      }

      return count;

   }

   public String replace(String oldValue, String newValue){
      for(int i = 0; i < size; i++){
         // 循环查找旧数据是否存在 存在则替换
         // 判断是否是需要被替换的数据
         if(values[i].equals (oldValue)){
            values[i] = newValue;
            return oldValue;
         }
      }
      return null;
   }

   public String replace(int index, String newValue){
      if(index < 0 || index >= size){
         throw new RuntimeException ("下标越界");
      }
      String oldValue = values[index];
      values[index] = newValue;
      return oldValue;
   }

   // 主函数测试
   public static void main(String[] args){
      MyArray myArray = new MyArray (10);
      for(int i = 0; i < 500; i++){
         myArray.addValue ("a" + i);
      }
      System.out.println ("size: " + myArray.size);
      myArray.get (400);
      myArray.remove (400);
      myArray.get (400);
      myArray.remove ("a1");
      myArray.get (1);
   }
}


```