数组: 存储多个数据

数组: 相同数据类型的有序集合
      一段连续的内存空间

特点:
    1.引用数据类型
    2.长度一旦确定不可改变
    3.存储的多个数据要求数据类型一致
    4.数组是有序的

索引|下标:
    第一个空间: 0
    最后一个空间 : 数组名.length-1

数组的长度: 数组名.length

操作数组中的数据:
    数组名[索引|下标]->确定数组中的某一块空间操作空间中的数据内容

结构:
    数组的声明
        数据类型[]  数组名;  --> 推荐
        数据类型  数组名[];
        int[] arr1;

    数组的初始化
        动态初始化: 先创建数组对象,然后赋值
            数据类型[]  数组名 = new 数据类型[长度];
            数据类型: 任意的数据类型
                     数组中存放数据的类型
        arr1 = new int[3];
        //为数组赋值
        arr1[0] = 100;
        arr1[1] = 101;
        arr1[2] = 102;

        //获取数组中的数据
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

            不同类型的数组每一个空间存在默认值:
                整数:0   小数:0.0  布尔: false 字符:空字符  引用: null

        静态初始化: 创建数组对象的同时赋值
            数据类型[]  数组名 = new 数据类型[]{值1,值2,值3...};
            数据类型[]  数组名 = {值1,值2,值3...};
        String[] arr3 = new  String[]{"张三","李四","王五","赵六"};
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        /*数组中的最后一个数据*/
        System.out.println(arr4[arr4.length-1]);

注意:
    1.ArrayIndexOutOfBoundsException 数组索引越界异常

数组的遍历
         1.普通for循环
         2.增强for循环|for..each
            for(数据类型 变量名i:数组名|集合名){
                每一次循环中,i代表数组中的每一个数据
            }

         注意:
            普通循环遍历操作索引,索引控制变化情况
            增强for循环遍历数组,只能从前到后遍历

        public class Class003_Each {
           public static void main(String[] args) {
               int[] arr = {1,2,3,4};

               //普通for循环
                //变量控制数组的索引
                for(int i=0;i<=arr.length-1;i++){
                    System.out.println(arr[i]);
                }

                //增强for循环
                for(int i:arr){
                    System.out.println(i);
                }
            }
        }

ArrayList 集合结构: 存储多个数据,长度可以根据数据的多少进行增删,有序有索引,存储相同的数据

HashSet 集合结构: 存储多个数据,无序去重

二维数组:数组中存放数组    声明:数据类型[][] 数组名;
初始化:
    动态初始化 : 先创建数组然后赋值
        数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
        特点: 内层的每一个一维数组长度相同
        int[][] arr1 = new int[2][3];
        //赋值
        arr1[0][0] = 1;
        arr1[0][1] = 2;
        arr1[0][2] = 3;

        arr1[1][0] = 4;
        arr1[1][1] = 5;
        arr1[1][2] = 6;

        System.out.println(arr1[0][0]);
        System.out.println(arr1[0][1]);
        System.out.println(arr1[0][2]);
        System.out.println(arr1[1][0]);
        System.out.println(arr1[1][1]);
        System.out.println(arr1[1][2]);

        数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
        特点: 内层的每一个一维数组没有构建,长度有构建的时候指定内层的每一个一维数组的创建按照一维数组的创建方式(动态,静态)
        double arr2[][] = new double[2][];
        //构建每一个一维数组
        arr2[0] = new double[3];
        arr2[0][0] = 1.1;
        arr2[0][1] = 2.2;
        arr2[0][2] = 3.3;

        arr2[1] = new double[]{3.3,4.4};

        System.out.println(arr2[0][0]);
        System.out.println(arr2[0][1]);
        System.out.println(arr2[0][2]);
        System.out.println(arr2[1][0]);
        System.out.println(arr2[1][1]);

    静态初始化 : 创建数组的同时赋值
         数据类型[][] 数组名 = new 数据类型[][]{{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};
         数据类型[][] 数组名 = {{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};
        char[][] arr3 = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
        System.out.println(arr3[0][0]);
        System.out.println(arr3[1][0]);
        System.out.println(arr3[1][1]);
        System.out.println(arr3[2][0]);
        System.out.println(arr3[2][1]);
        System.out.println(arr3[2][2]);

二维数组的遍历方式:
           1. 普通嵌套普通
           2. 普通嵌套增强
        char[][] arr = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
        for(int i = 0;i<arr.length;i++){
            for(char ch:arr[i]){
                System.out.println(ch);
            }
        }
           3. 增强嵌套增强
        for(char[] chars:arr){
            for(char ch:chars){
                System.out.println(ch);
            }
        }
           4. 增强嵌套普通