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;
       }
  
   }