Java（5）数组

• 数组
• 相同数据类型的元素组成的集合我们称之为数组
• 数组中能够存储元素的数量最大值我们称之为该数组的长度
• 数组声明后该数组的长度不可修改
• 数组声明后没有赋值的index位置上赋值为该数组数据类型的初始值（默认值）

1 数组

    @Test
    public void test() {
        int a = 10;
        int b = 20;
        int c = 30;
        int x = 10, y = 20, z = 30;
        // 相同数据类型的元素组成的集合我们称之为数组
        int[] array = {10, 20, 30};
    }

2 数组赋值与读取

    @Test
    public void test() {
        // 声明一个长度为5的数组
        int[] array = new int[5];
        // 为下标为2的位置赋值
        array[2] = 20;
        // 读取下标为2位置上元素的值
        System.out.println(array[2]);
    }
    //20

3 数组的三种声明方式

    @Test
    public void test() {
        // 注意[]中的5代表长度而非元素的值
        int[] arr0 = new int[5];
        // 注意{}中的5代表元素的值而非长度
        int[] arr1 = new int[]{5};
        int[] arr2 = {5};
    }

4 数组下标越界

    @Test
    public void test() {
        // 声明一个长度为5的数组
        int[] array = new int[5];
        // 为下标为2的位置赋值
        array[2] = 20;
        // 读取下标为2位置上元素的值
        System.out.println(array[2]);
        // 修改下标为2的位置元素的值
        array[2] = 200;
        System.out.println(array[2]);
        // java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
        // 数组下标越界
        System.out.println(array[5]);
    }
    /*
20
200

java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
     */

5 读取未赋值数组下标位置，获取到的是该数组类型的默认值

    @Test
    public void test01() {
        // 声明一个长度为5的数组
        int[] array = new int[5];
        // 为下标为2的位置赋值
        array[2] = 20;
        // 读取下标为2位置上元素的值
        System.out.println(array[2]);
        // 读取没有赋值的位置上的元素读取到的是该数组数据类型的默认值
        System.out.println(array[3]);
    }
    /*
20
0
     */

    @Test
    public void test02() {
        byte[] a0 = new byte[5];
        short[] a1 = new short[5];
        int[] a2 = new int[5];
        long[] a3 = new long[5];
        double[] a4 = new double[5];
        float[] a5 = new float[5];
        char[] a6 = new char[5];
        boolean[] a7 = new boolean[5];
        String[] a8 = new String[5];
        // byte 0
        System.out.println(a0[2]);
        // short 0
        System.out.println(a1[2]);
        // int 0
        System.out.println(a2[2]);
        // long 0
        System.out.println(a3[2]);
        // double 0.0
        System.out.println(a4[2]);
        // float 0.0
        System.out.println(a5[2]);
        // char 空字符
        System.out.println(a6[2]);
        // boolean false
        System.out.println(a7[2]);
        // null
        System.out.println(a8[2]);
        // 空字符
        System.out.println("\0");
    }
    /*
0
0
0
0
0.0
0.0

false
null

    */

6 数组的数据类型与长度

    @Test
    public void test() {
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        System.out.println(arr0[0]);
        System.out.println(arr0[1]);
        System.out.println(arr0[2]);
        // 数组为引用数据类型
        // 数组一旦声明长度不可变
        arr0 = new String[5];
        System.out.println(arr0[0]);
        System.out.println(arr0[1]);
        System.out.println(arr0[2]);
    }
    /*
我
爱
你
null
null
null
    */

7 数组的遍历

   @Test
    public void test01() {
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        System.out.println(arr0[0]);
        System.out.println(arr0[1]);
        System.out.println(arr0[2]);
    }
    /*
我
爱
你
    */

    @Test
    public void test02() {
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        // 结合循环遍历输出数组中元素的值
        for (int i = 0; i < 3; i++) {
            System.out.println(arr0[i]);
        }
    }
    /*
我
爱
你
    */

    @Test
    public void test10() {
        // 遍历数组
        String[] a = new String[3];
        a[0] = "我";
        a[1] = "爱";
        a[2] = "你";
        // 数组点length获取该数组的长度
        System.out.println("数组a的长度 >>> " + a.length);
    }
    //数组a的长度 >>> 3

    @Test
    public void test11() {
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        // 结合循环遍历输出数组中元素的值
        for (int i = 0; i < arr0.length; i++) {
            System.out.println(arr0[i]);
        }
    }
    /*
我
爱
你

    */

8 Arrays.toString

import java.util.Arrays;

    @Test
    public void test01() {
        // 遍历数组
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        System.out.println(Arrays.toString(arr0));
    }
    //[我, 爱, 你]

    @Test
    public void test02() {
        String[] a = {"我", "爱", "你"};
        String b = Arrays.toString(a);
        System.out.println(b);
    }
    //[我, 爱, 你]

9 for循环实现Arrays.toString

    @Test
    public void test() {
        // 遍历数组
        String[] arr0 = new String[3];
        arr0[0] = "我";
        arr0[1] = "爱";
        arr0[2] = "你";
        System.out.println(Arrays.toString(arr0));
        System.out.print("[");
        for (int i = 0; i < arr0.length; i++) {
            if (i != arr0.length - 1) {
                System.out.print(arr0[i] + ", ");
            } else {
                System.out.print(arr0[i]);
            }
        }
        System.out.println("]");
    }
    /*
[我, 爱, 你]
[我, 爱, 你]
    */

10 foreach遍历数组

   @Test
    public void test() {
        String[] array = {"我", "爱", "你"};
        for (String string : array) {
            System.out.println(string);
        }
    }
    /*
我
爱
你
    */

11 数组合并

    @Test
    public void test01() {
        int[] arr0 = {0, 2, 4, 6, 8};
        int[] arr1 = {1, 3, 5, 7, 9};
        // 需求：将以上两个新的数组合并生成一个新的数组
        // 思路：
        // 1、声明一个新的数组长度为两个数组长度的和
        // 2、将第一个数组循环赋值给新数组
        // 3、讲第二个数组循环赋值给新数组 注意：第二个数组赋值时的起始位置为第一个数组的长度
        int[] arr2 = new int[arr0.length + arr1.length];
        // 遍历第一个数组
        for (int i = 0; i < arr0.length; i++) {
            // 将获取到的元素赋值给新数组
            arr2[i] = arr0[i];
        }
        // 遍历第二个数组
        for (int i = 0; i < arr1.length; i++) {
            // 将获取到的元素赋值给新数组
            // 注意第二个数组赋值的起始位置为第一个数组长度
            arr2[arr0.length + i] = arr1[i];
        }
        System.out.println(Arrays.toString(arr2));
    }
    //[0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

    @Test
    public void test02() {
        int[] arr0 = {0, 2, 4, 6, 8};
        int[] arr1 = {1, 3, 5, 7, 9};
        // 需求：将以上两个新的数组合并生成一个新的数组
        // 思路：
        // 1、声明一个新的数组长度为两个数组长度的和
        // 2、将第一个数组循环赋值给新数组
        // 3、讲第二个数组循环赋值给新数组 注意：第二个数组赋值时的起始位置为第一个数组的长度
        int[] arr2 = new int[arr0.length + arr1.length];
        for (int i = 0; i < arr2.length; i++) {
            if (i < arr0.length) {
                arr2[i] = arr0[i];
            } else {
                arr2[i] = arr1[i - arr0.length];
            }
        }
        System.out.println(Arrays.toString(arr2));
    }
    //[0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

12 数组依次合并

    @Test
    public void test() {
        int[] arr0 = {0, 2, 4, 6, 8};
        int[] arr1 = {1, 3, 5, 7, 9};
        // 需求：将以上两个新的数组合并生成一个新的数组
        // 思路：
        // 1、声明一个新的数组长度为两个数组长度的和
        // 2、将第一个数组循环赋值给新数组
        // 3、讲第二个数组循环赋值给新数组 注意：第二个数组赋值时的起始位置为第一个数组的长度
        int[] arr2 = new int[arr0.length + arr1.length];
        for (int i = 0; i < arr2.length; i++) {
            if (i < arr0.length) {
                arr2[i] = arr0[i];
            } else {
                arr2[i] = arr1[i - arr0.length];
            }
        }
        System.out.println(Arrays.toString(arr2));
    }
    //[0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

13 长度不一致的数组依次合并

   @Test
    public void test() {
        int[] arr0 = {0, 2};
        int[] arr1 = {1, 3, 5, 7, 9};
        // 按照下标相同的位置依次将以上两个数组中的元素插入新的数组
        // 思路：
        // 1、声明一个新的数组长度为两个数组长度的和
        // 2、将第一个数组循环赋值给新数组 注意:下标规律为2n
        // 3、讲第二个数组循环赋值给新数组 注意:下标规律为2n+1 第二个数组长度如果与第一个数组长度不一致的时候怎么办
        // 4、当第一个数组复制完成之后第二个数组依次赋值即可
        int[] arr2 = new int[arr0.length + arr1.length];
        // 循环次数问两个中长度最大的那个长度
        int max = arr1.length > arr0.length ? arr1.length : arr0.length;
        // 循环次数问两个中长度最小的那个长度
        int min = arr1.length < arr0.length ? arr1.length : arr0.length;
        // 返回长度最长的你那个数组
        int[] maxArray = arr0.length > arr1.length ? arr0 : arr1;
        for (int i = 0; i < max; i++) {
            // 获取第一个数组的元素
            // int a = arr0[i];
            // 获取第一个数组相同下标位置上的元素
            // int b = arr1[i];
            // 依次赋值
            if (i < min) {
                arr2[2 * i] = arr0[i];
                arr2[2 * i + 1] = arr1[i];
            } else {
                arr2[i + min] = maxArray[i];
            }
        }
        System.out.println(Arrays.toString(arr2));
    }
    //[0, 1, 2, 3, 5, 7, 9]