2023.3.23 java基础-数组与二维数组

知识点概括

一维数组

数组的静态初始化

数组元素的访问

数组遍历操作

数组的动态初始化

数组内存图

数组常见问题

二维数组

二维数组静态初始化

二维数组遍历

二维数组动态初始化

二维数组内存图

---

数组:数组指的是一种容器，可以用来存储同种数据类型的多个值

1、一维数组

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

数组静态初始化

格式一：数据类型[] 数组名

范例：int[] array

实例:int[] array = new int[]{ 11，22，33 };

简化形式：int [] array = {11,22,33}

格式二：数据类型数组名[]

范例：int array[]

实列: int array[] =new int[]{11,22,33}

简化形式：int array[] = {11,22,33}

数组元素的访问

格式：数组名[索引];

索引：索引是数组容器中空间的编号，编号从0开始，逐个+1增长

数组元素的遍历操作

将数组中所有的内容取出来，取出来之后可以（打印，求和，判断..）

 /**
         * 静态数组的初始化
         * 数组的访问
         * 数组元素的遍历
         */
        //初始化静态数组
        int[] arr1= new int[]{1,23,43};
        //简化形式
        int[] arr2 = {12,34,223};
        //数组的遍历
        for (int i = 0; i < arr1.length; i++) {
            //数据元素的访问
            System.out.println(arr1[i]);
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }

需求：已知数组元素为{11,22,33,44,55} 请将数组中偶数元素取出并求和,最后打印求和结果

 /**
         * 数据的基本应用
         * 求数组偶数和
         */
        int[] array1 = new int[]{11, 22, 33,44,55};
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
            sum += array1[i];
        }
        System.out.println("数组元数和:" + sum);

需求：对数组进行遍历,并求出最大值

/**
         * 需求：对数组进行遍历,并求出最大值
         */
        int[] arr = {1, -22, 78, 20, 666};
        //取第一个值赋值给max
        int max = arr[0];
        //实现遍历,从第一个开始
        for (int i = 1; i < arr.length; i++) {
            //用三元表达式求最大值
            max = max > arr[i] ? max : arr[i];
        }
        System.out.println(max);

数组动态初始化

格式：数据类型[] 数组名 = new 数据类型[数组长度]

范例：int[] arr = new int[3];

动态初始化：手动指定数组长度，由系统给出默认初始化值。

动态类型默认值：

需求：键盘录入5个整数并求出最大值

 /**
         * 需求:键盘录入5个整数并求出最大值
         */
        Scanner scanner = new Scanner(System.in);
        //初始化动态数组
        int[] arr = new int[5];
        int max=0;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
            max = max>arr[i]?max:arr[i];
        }
        System.out.println(max);

需求：定义一个长度为5的一维数组，给每个元素赋值.(要求数组中每个元素的值是20-80的随机数)

/**
         *需求：定义一个长度为5的一维数组，给每个元素赋值.
         *  (要求数组中每个元素的值是20-80的随机数)
         */
        //初始化动态数组
        int[] arr = new int[5];
        //调用封装random类
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(60)+20;
        }
        //打印随机数 数组
        System.out.println(Arrays.toString(arr));
   

需求：键盘录入一个整数作为数组的长度，随后再次键盘录入数据并将数组存满 从数组中找出最小值，并将最小值打印在控制台

 /**
         * 需求：键盘录入一个整数作为数组的长度，随后再次键盘录入数据并将数组存满
         * * 从数组中找出最小值，并将最小值打印在控制台
         */
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数组的长度:");
        //作为数组的长度
        int num = scanner.nextInt();
        int[] arr = new int[num];
        for (int i = 0; i < arr.length; i++) {
            System.out.print("请输入数组的第" + (i + 1 )+ "个值:");
            arr[i] = scanner.nextInt();
        }
        //定义最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            min = min < arr[i] ? min : arr[i];
        }
        System.out.println(Arrays.toString(arr));
        System.out.println("最小值为" + min);

数组内存图

Java内存分配分为：栈、堆、方法区、本地方法栈、寄存器

数组常见的问题

ArrayIndexOutOfBoundsException 当访问了数组中不存在的索引，就会引发索引越界异常

NullPointerException当引用数据类型变量被赋值为 null 之后，地址的指向被切断，还继续访问堆内存数据，就会引发空指针异常

---

2、二维数组

二维数组介绍：二维数组是一种容器，该容器用于存储一维数组

二维数组静态初始化

格式：数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1, 元素2}};

范例：int[][] arr = new int[][]{{11,22},{33,44}};

简化格式：数据类型[][] 数组名 = {{元素1,元素2}, {元素1, 元素2}};

范例：int[][] arr = {{11,22},{33,44}};

二维数组的元素访问

格式：数组名[索引][索引];

范例：int[][] arr = new int[][]{{11,22},{33,44}};

arr[1][0];

二维数组遍历

需求：已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} }; 遍历该数组，取出所有元素并打印

/**
         * 需求：已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} };
         * 遍历该数组，取出所有元素并打印
          */
        //静态初始化二维数组
        int[] [] arr = {{11,22,33},{33,44,55}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }

需求：已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} }; 对内部存储的元素累加求和，并将结果输出在控制台

 /**
         * 需求：已知一个二维数组 arr = { {11 , 22 , 33} , {33 , 44 , 55} };
         * 对内部存储的元素累加求和，并将结果输出在控制台
         */
        int[][] arr = {{11, 22, 33}, {33, 44, 55}};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        System.out.println(sum);

二维数组动态初始化

格式：数据类型[][] 数组名 = new 数据类型[m][n];

m表示这个二维数组，可以存放多少个一维数组

n表示每一个一维数组，可以存放多少个元素

范例：int[][] arr = new int[2][3];

二维数组内存图