day05 数组和二维数组

标签：arr int 元素 day05 33 二维 数组

今日内容

• 数组

• 二维数组

教学目标

能够知道数组的概念和作用

能够使用数组的两种初始化方式

能够通过索引访问数组元素

能够完成数组的遍历

能够理解数组在内存中的操作过程

能够看懂数组常见的问题并知道如何解决

能够完成数组的常见操作（求和、求最值）

能够使用二维数组的两种初始化方式

能够对二维数组进行元素访问

第八章 数组

8.1 数组介绍

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

8.2 数组的定义

8.2.1 第一种格式

数据类型[] 数组名

示例：

int[] arr;        
double[] arr;      
char[] arr;

8.2.2 第二种格式

数据类型 数组名[]

示例：

int arr[];
double arr[];
char arr[];

8.3 数组的静态初始化

8.3.1 什么是初始化

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

8.3.2 静态初始化格式

• 完整版格式

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

• 简化版格式

数据类型[] 数组名 = {元素1,元素2,...};

示例代码：

// 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素2...};
// 创建了一个int类型的数组, 数组名叫arr, 数组中存储了 11 22 33 这个三个数据.
int[] arr = new int[]{11, 22, 33};
System.out.println(arr);

// 数据类型[] 数组名 = {元素1, 元素2, 元素2...};
double[] dArr = {12.3, 22.3, 33.3};
System.out.println(dArr);

8.4 数组元素访问

8.4.1 什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

8.4.2访问数组元素格式

数组名[索引];

示例代码：

int[] arr = {11, 22, 33, 44, 55};

// 需求1: 将元素44取出来打印在控制台
System.out.println(arr[3]);

// 需求2: 修改0号元素位置元素为66, 修改后取出并打印.
arr[0] = 66;
System.out.println(arr[0]);

8.5 数组遍历

概念：

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

注意事项：

• 遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印！

• 数组的长度属性：arr.length

• IDEA快速生成遍历的方式：数组名 + fori 回车

代码示例：

int[] arr = {11, 22, 33, 44, 55, 33, 44, 55, 33, 44, 55, 33, 44};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

练习1:

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

• 分析：
  1.静态初始化数组
  2.定义求和变量
  3.遍历数组取出每一个元素
  4.判断当前元素是否是偶数，是的话跟求和变量做累加操作
  5.打印求和变量

• 示例代码：

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

	    分析：
            1. 定义求和变量
            2. 静态初始化数组
            3. 遍历数组取出每一个元素
            4. 判断当前元素是否是偶数，是的话跟求和变量做累加操作
            5. 打印求和变量

     */
    public static void main(String[] args) {
        // 1. 定义求和变量
        int sum = 0;
        // 2. 静态初始化数组
        int[] arr = {11, 22, 33, 44, 55};
        // 3. 遍历数组取出每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 4. 判断当前元素是否是偶数，是的话跟求和变量做累加操作
            if (arr[i] % 2 == 0) {
                sum += arr[i];
            }
        }

        // 5. 打印求和变量
        System.out.println(sum);
    }
}

练习2：

• 需求：已知数组元素为 {5,44,33,55,22} 请找出数组中最大值并打印在控制台

分析：
1. 假设数组中第一个元素就是最大值
2. 遍历数组, 取出每一个元素 (准备进行比较)
3. 逐个进行比较，找到更大的，max变量记录更大的数据
4. 找到了更大了, 让max, 记录这个更大的元素
5. 打印最大值

• 示例代码：

public class ArrayTest2 {
    /*
        需求：已知数组元素为 {5,44,33,55,22} 请找出数组中最大值并打印在控制台
     */
    public static void main(String[] args) {
        int[] arr = {5, 44, 33, 55, 22};

        // 1. 假设数组中第一个元素就是最大值
        int max = arr[0];

        // 2. 遍历数组, 取出每一个元素 (准备进行比较)
        for (int i = 1; i < arr.length; i++) {
            // 3. 比较
            if(arr[i] > max){
                // 4. 找到了更大了, 让max, 记录这个更大的元素
                max = arr[i];
            }
        }

        // 5. 打印最大值
        System.out.println("最大值为:" + max);
    }
}

8.6 数组动态初始化

8.6.1 什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

8.6.2 动态初始化格式

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

8.6.3 动态初始化格式详解

• 等号左边：

• • int:数组的数据类型

• • []:代表这是一个数组

• • arr:代表数组的名称

• 等号右边：

• • new:为数组开辟内存空间

• • int:数组的数据类型

• • []:代表这是一个数组

• • 5:代表数组的长度

代码 :

// 数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[3];

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

arr[0] = 11;
arr[1] = 22;
arr[2] = 33;

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

8.7 内存分配

8.7.1 内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

8.7.2 java中的内存分配

• 目前我们只需要记住两个内存，分别是：栈内存和堆内存？
  | 区域名称   | 作用                                                       |
  | ---------- | ---------------------------------------------------------- |
  | 寄存器     | 给CPU使用，和我们开发无关。                                |
  | 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。          |
  | 方法区     | 存储可以运行的class文件。                                  |
  | 堆内存     | 存储对象或者数组，new来创建的，都存储在堆内存。            |
  | 方法栈     | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
  |||

8.8.1 一个数组的内存图

8.8.2 两个数组指向相同空间内存图

8.9 数组常见两个小问题

8.9.1 索引越界异常

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

代码示例：

int[] arr = {11, 22, 33};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[10]);//当访问了数组中不存在的索引，就会引发索引越界异常。

核心点：

要知道索引的范围。

• 最小索引：0

• 最大索引：数组的长度 - 1

8.9.2 空指针异常

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

代码示例：

int[] arr = new int[2];
arr = null;
System.out.println(arr[0]);

内存图解：

第九章 二维数组

9.1 二维数组介绍

概述：

二维数组也是一种容器，该容器存储的都是一维数组容器。

一维数组可以看成是装数据的小箱子。然后我们把小箱子放到一个大箱子当中，这个大箱子就是二维数组。

使用场景：

某公司季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

分析：

这样的数据我们就可以用二维数组，定义四个一维数组装每个月的数据。

然后再把四个一维数组放到二维数组当中。

9.2 二维数组静态初始化

完整格式 :

数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...}

简化格式 :

数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

代码示例：

//完整格式
int[][] arr = new int[][]{{11,22},{33,44}};

//简写格式：
int[][] arr = {{11,22,33}, {44,55,66}};

9.3 二维数组元素访问

格式：

数组名[m][n]

解释：

数组名：就是二维数组的名字。

m：表示二维数组中第几个一维数组。（从0索引开始计算）

n：表示一维数组中第几个元素。（从0索引开始计算）

代码示例：

//定义一个二维数组
int[][] arr = {{11,22,33}, {44,55,66}};

//0表示获取二维数组中0索引上的一维数组。
//2表示获取该一维数组中2索引上的元素。
System.out.println(array[0][2]);

11.3 二维数组遍历

需求 :

已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};

遍历该数组，取出所有元素并打印

步骤 :

1. 遍历二维数组，取出里面每一个一维数组

1. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

代码示例：

int[][] arr = {{11, 22, 33}, {33, 44, 55}};
// 1. 遍历二维数组，取出里面每一个一维数组
for (int i = 0; i < arr.length; i++) {
    // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}

9.4 二维数组动态初始化

格式：

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

代码示例：

int[][] arr = new int[3][3];

// 向二维数组中存储元素
arr[0][0] = 11;
arr[0][1] = 22;
arr[0][2] = 33;

arr[1][0] = 11;
arr[1][1] = 22;
arr[1][2] = 33;

arr[2][0] = 11;
arr[2][1] = 22;
arr[2][2] = 33;

//遍历二维数组
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}

9.5 二维数组内存图

核心点：

二维数组实际存储的是一维数组的地址值。

内存图：

9.6 二维数组案例-打乱二维数组

• 需求：将一维数组
  int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
  打乱后，存入二维数组中

• 分析：
  1.动态初始化二维数组，准备存储打乱后的数据
  2.打乱一维数组
  3.将一维数组中，打乱后的元素，存入二维数组
  4.遍历并打印二维数组数据

• 代码实现：

import java.util.Random;

public class Test7 {
    /*
        需求：将一维数组
            int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
            打乱后，存入二维数组中


        分析：
            1. 动态初始化二维数组，准备存储打乱后的数据
            2. 打乱一维数组
            3. 将一维数组中，打乱后的元素，存入二维数组
            4. 遍历并打印二维数组数据

     */
    public static void main(String[] args) {

        int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

        // 1. 动态初始化二维数组，准备存储打乱后的数据
        int[][] arr = new int[4][4];
        // 2. 打乱一维数组
        Random r = new Random();
        for (int i = 0; i < nums.length; i++) {
            int index = r.nextInt(nums.length);
            int temp = nums[i];
            nums[i] = nums[index];
            nums[index] = temp;
        }
        // 3. 将一维数组中，打乱后的元素，存入二维数组
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = nums[index];
                index++;
            }
        }
        // 4. 遍历并打印二维数组数据
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

标签：arr,int,元素,day05,33,二维,数组
From： https://blog.csdn.net/Darling912/article/details/143659647