JDK源码阅读-------自学笔记(五)(浅析数组)

一、数组基础

1、定义和特点

• 数组也可以看做是对象，数组变量属于引用类型，数组中每个元素相当于该队形的成员变量，数组对象存储在堆中.
  
  

2、初始化数组

• 常用类初始化
  

           // 整型初始化
          int[] integerInitialization = new int[10];

• 对象初始化
  

          // 对象初始化
          User[] usersInitialization = new User[10];

3、数组赋值

• 动态初始化（根据数组角标）
  

          // 整型初始化
          int[] integerInitialization = new int[10];
  
          // 整型赋值
          integerInitialization[0] = 1;
          integerInitialization[1] = 2;

• 循环赋值
  

          // 整型初始化
          int[] integerInitialization = new int[10];
  
          // 循环赋值
          for (int i = 0; i < integerInitialization.length; i++) {
              integerInitialization[i]=10*i;
          }

• 静态初始化
  常用类初始化
  

          // 整型初始化
          int[] integerInitialization = {1,2,3,4,5,6,7,8,9};

  
  对象初始化
  

          // 对象静态初始化
          User[] usersInitialization ={new User(101,"龙五"),new User(102,"李四")};

• 默认初始化
  注意:当默认初始化的时候,会按照设置的数组大小自动填入数组长度多个0,布尔型为false,引用型为null.
  

          // 默认初始化
          int[] integerInitialization = new int[3];
  
          // 测试查看默认值
          System.out.println("第一个元素"+integerInitialization[0]);
          System.out.println("第二个元素"+integerInitialization[1]);
          System.out.println("第三个元素"+integerInitialization[2]);

4、数组遍历取值

• 循环
  

          // 整型初始化
          int[] integerInitialization = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  
          // 循环获取元素
          for (int i = 0; i < integerInitialization.length; i++) {
              System.out.println("第" + (i + 1) + "个元素" + integerInitialization[i]);
          }

• foreach语句
  

          // 整型初始化
          int[] integerInitialization = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  
          // foreach获取元素
          for (int i : integerInitialization) {
              System.out.println("第" + i + "个元素" + i);
          }

二、数组拷贝

• 容器拷贝，底层就是数组拷贝
• 使用方法
  源码分析:
  

      /**
       * @param src     源数组(从这个数组中拷出元素).
       * @param srcPos  源数组起始位置.
       * @param dest    目的数组(拷贝到这里元素).
       * @param destPos 目的数组起始位置.
       * @param length  拷贝数组的长度(拷贝多少个元素到目的数组).
       * @throws IndexOutOfBoundsException 拷贝会产生数组越界的异常.
       * @throws ArrayStoreException       源数组和目的数组类型要一致,否则,会产生类型不一致的异常.
       * @throws NullPointerException      源数组和目的数组中有一个为空,就会产生空指针异常.
       */
      public static native void arraycopy(Object src, int srcPos,
                                          Object dest, int destPos,
                                          int length);

  
  使用实例:

          // 整型初始化
          int[] integerInitialization = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  
          // 目的数组默认初始化
          int[] destPosition = new int[10];
  
          // 数组拷贝,从integerInitialization的第一个位置起拷贝8个元素到目的数组第二个位置起
          System.arraycopy(integerInitialization, 0, destPosition, 1, 8);
  
          System.out.println("数组中得到的拷贝元素:" + Arrays.toString(destPosition));

• 数组删除的本质，也是拷贝实现的方式
  

  class DemoApplicationTests {
  
  
      public static void main(String[] args) {
  
          // 整型初始化
          int[] integerInitialization = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  
          // 删除第五个元素,就是6
          integerInitialization = deletedElements(integerInitialization, 5, 5, integerInitialization.length);
  
          // 删除后的结果
          System.out.println("数组中得到的拷贝元素:" + Arrays.toString(integerInitialization));
  
  
      }
  
      /**
       * 数组删除元素的本质,是数组自身的拷贝
       * <p>
       * 算法:
       * 数组从startCopyLocation个位置开始拷贝,startCopyLocation后的元素被拷贝了,然后向前移动了一位重新放回数组
       *
       * @param objects           需要修改的数组
       * @param startCopyLocation 拷贝元素的起始位置
       * @param deletedLocation   存放元素的起始位置
       * @param length            拷贝几个元素
       * @return 删除后的数组
       */
      private static int[] deletedElements(int[] objects, int startCopyLocation, int deletedLocation, int length) {
  
          int[] newList = objects;
  
          System.arraycopy(newList, startCopyLocation + 1, newList, deletedLocation, length - deletedLocation - 1);
  
          newList[length - 1] = 0;
  
          return newList;
  
      }
  
  
  }

三、数组扩容

• 算法：先定义一个更大的数组，然后将原来数组的内容原封不动的拷贝到新数组中
  

  class DemoApplicationTests {
  
  
      public static void main(String[] args) {
  
          // 整型初始化
          int[] integerInitialization = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  
          // 在2的位置添加一个元素10
          integerInitialization = addElement(integerInitialization, 2, 10);
  
  
          // 删除后的结果
          System.out.println("数组中添加元素:" + Arrays.toString(integerInitialization));
  
  
      }
  
  
      /**
       * 插入元素
       *
       * @param ints            需要插入元素的数组
       * @param elementLocation 插入元素的位置
       * @param value           插入的值
       * @return 新的数组
       */
      private static int[] addElement(int[] ints, int elementLocation, int value) {
  
          // 数组扩容
          int[] newElements = new int[ints.length << 1];
  
          // 拷贝elementLocation个元素
          System.arraycopy(ints, 0, newElements, 0, elementLocation + 1);
  
          // 添加要插入的元素
          newElements[elementLocation + 1] = value;
  
          // 在插入的元素后,把数组原来后边的元素拷贝进来
          System.arraycopy(ints, elementLocation + 1, newElements, elementLocation + 2, ints.length - elementLocation - 1);
  
          return newElements;
      }
  
  }