一、数组概述和定义格式说明
为什么要有数组（容器）：
- 为了存储同种数据类型的多个值
数组概念：
- 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
- 数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义格式：
- 数据类型[] 数组名 = new 数据类型[数组的长度];
1 class JavaDemo {
2 public static void main(String[] args) {
3 // 数据类型[] 数组名 = new 数据类型[数组的长度];
4 int[] arr = new int[5]; // 声明初始化了长度为5、int类型的一维数组
5
6 /*
7 * 左边：
8 * int：数据类型
9 * []：代表的数组，几个括号就代表几维数组
10 * arr：合法的标识符
11 *
12 * 右边：
13 * new：创建新的实体或对象
14 * int：数据类型
15 * []：代表的数组
16 * 5：代表的数组长度
17 */
18 }
19 }
二、数组的初始化动态初始化
什么是数组的初始化：
- 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
如何对数组进行初始化：
- 动态初始化 只指定长度，由系统给出初始化值
- int[] arr = new int[5];
- 静态初始化 给出初始化值，由系统决定长度
动态初始化的格式：
- 数据类型[] 数组名 = new 数据类型[数组长度];
1 /*
2 * 整数类型：byte、short、int、long默认初始化值都是0
3 * 浮点类型：float、double默认初始化值都是0.0
4 * 布尔类型：Boolean默认初始化值是false
5 * 字符类型：char默认初始化值是'\u0000'
6 * char在内存中占的两个字节，是16个二进制
7 * \u0000，每一个0其实代表的是16进制的0，那么四个0就是代表16个二进制位
8 *
9 * [I@15db9742
10 * [：代表是数组，几个就代表几维
11 * I：代表的是int类型
12 * @：固定格式
13 * 15db9742：代表的是十六进制的地址值
14 */
15 class JavaDemo {
16 public static void main(String[] args) {
17 // 数据类型[] 数组名 = new 数据类型[数组的长度];
18 int[] arr = new int[5]; // 数组的动态初始化，在内存中开辟连续的5块空间
19
20 System.out.println(arr[0]); // 系统给出默认初始化值，整数类型的都是0
21 arr[0] = 10;
22 System.out.println(arr[0]);
23 System.out.println(arr); // [I@15db9742
24 }
25 }
三、Java中的内存分配以及栈和堆的区别
栈(掌握)：
- 存储局部变量 ：
- 局部变量：定义在方法声明上和方法中的变量
堆(掌握)：
- 存储new出来的数组或对象
方法区：
- 面向对象部分讲解
本地方法区：
- 和系统相关
寄存器：
- 给CPU使用
1 /*
2 * A:栈(掌握)
3 * 存储局部变量 ：
4 * 局部变量：定义在方法声明上和方法中的变量
5 * B:堆(掌握)
6 * 存储new出来的数组或对象
7 * C:方法区
8 * 面向对象部分讲解
9 * D:本地方法区
10 * 和系统相关
11 * E:寄存器
12 * 给CPU使用
13 */
14 class JavaDemo {
15 public static void main(String[] args) {
16 int[] arr = new int[3]; // 数组的动态初始化，在内存中开辟连续的3块空间
17 }
18 }
数组的内存图解1一个数组
1 class JavaDemo {
2 public static void main(String[] args) {
3 int[] arr = new int[3]; // 数组的动态初始化，在内存中开辟连续的3块空间
4 System.out.println(arr);
5 arr[0] = 10;
6 arr[1] = 20;
7 System.out.println(arr[0]);
8 System.out.println(arr[1]);
9 }
10 }
数组的内存图解2二个数组
1 class JavaDemo {
2 public static void main(String[] args) {
3 int[] arr1 = new int[3]; // 创建数组，长度为3
4 int[] arr2 = new int[3]; // 创建数组，长度为3
5
6 System.out.println(arr1); // 打印数组地址
7 System.out.println(arr2);
8
9 arr1[0] = 10; // 给第一个数组的第一个元素赋值
10 arr2[1] = 20; // 给第二个数组的第二个元素赋值
11
12 System.out.println(arr1[0]);
13 System.out.println(arr1[1]);
14 System.out.println(arr1[2]);
15 System.out.println("-------------");
16 System.out.println(arr2[0]);
17 System.out.println(arr2[1]);
18 System.out.println(arr2[2]);
19 }
20 }
数组的内存图解3三个引用两个数组
1 class JavaDemo {
2 public static void main(String[] args) {
3 int[] arr1 = new int[3]; // 创建数组，长度为3
4 int[] arr2 = new int[5]; // 创建数组，长度为5
5 int[] arr3 = arr2;
6
7 System.out.println(arr1); // 打印数组地址
8 System.out.println(arr2);
9 System.out.println(arr3);
10
11 arr1[0] = 10;
12 arr1[1] = 20;
13
14 arr2[1] = 30;
15 arr3[1] = 40;
16 arr3[2] = 50;
17
18 System.out.println(arr1[0]);
19 System.out.println(arr1[1]);
20 System.out.println(arr1[2]);
21 System.out.println("-------------");
22 System.out.println(arr2[0]);
23 System.out.println(arr2[1]);
24 System.out.println(arr2[2]);
25 System.out.println(arr2[3]);
26 System.out.println(arr2[4]);
27 System.out.println("-------------");
28 System.out.println(arr3[0]);
29 System.out.println(arr3[1]);
30 System.out.println(arr3[2]);
31 System.out.println(arr3[3]);
32 System.out.println(arr3[4]);
33 }
34 }
四、数组的初始化静态初始化及内存图
静态初始化的格式：
- 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
- 简化格式：
- 数据类型[] 数组名 = {元素1,元素2,…};
1 /*
2 * A:静态初始化的格式：
3 * 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
4 * 简化格式：
5 * 数据类型[] 数组名 = {元素1,元素2,…};
6 * B:案例演示
7 * 对数组的解释
8 * 输出数组名称和数组元素
9 * C:画图演示
10 * 一个数组
11 */
12 class JavaDemo {
13 public static void main(String[] args) {
14 // 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
15 // int[] arr = new int[5]{11, 22, 33, 44, 55}; // 不允许动静结合
16 // 静态初始化简写形式
17 int[] arr1 = {11, 22, 33, 44, 55};
18
19 // int[] arr; // 声明数组
20 // arr = new int[]{11, 22, 33, 44, 55};
21
22 // int[] arr2;
23 // arr2 = {11, 22, 33, 44, 55}; // 简写形式声明和赋值在同一行
24 System.out.println(arr1);
25 System.out.println(arr1[0]);
26 System.out.println(arr1[1]);
27 System.out.println(arr1[2]);
28 System.out.println(arr1[3]);
29 System.out.println(arr1[4]);
30 }
31 }
四、数组操作的两个常见小问题越界和空指针
1 /*
2 * A:案例演示
3 * a:ArrayIndexOutOfBoundsException:数组索引越界异常
4 * 原因：你访问了不存在的索引。
5 * b:NullPointerException:空指针异常
6 * 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
7 * int[] arr = {1,2,3};
8 * arr = null;
9 * System.out.println(arr[0]);
10 */
11 class JavaDemo {
12 public static void main(String[] args) {
13 int[] arr = new int[5];
14
15 // System.out.println(arr[5]); // 当访问数组中不存在的索引，会出现索引越界异常
16
17 arr = null;
18 System.out.println(arr[0]); // 当数组引用赋值为null，再去调用数组中的元素就会出现空指针异常
19 }
20 }
五、数组的操作1遍历
1 /*
2 *A:案例演示
3 * 数组遍历：就是依次输出数组中的每一个元素。
4 * 数组的属性:arr.length数组的长度
5 * 数组的最大索引:arr.length - 1;
6 */
7 class JavaDemo {
8 public static void main(String[] args) {
9 int[] arr = {11, 22, 33, 44, 55};
10 for (int i = 0; i < arr.length; i++) {
11 System.out.println(arr[i]);
12 }
13 }
14 }
六、数组的操作2获取最值
1 /*
2 *A:案例演示
3 * 数组遍历：就是依次输出数组中的每一个元素。
4 * 数组的属性:arr.length数组的长度
5 * 数组的最大索引:arr.length - 1;
6 */
7 class JavaDemo {
8 public static void main(String[] args) {
9 int[] arr = {33, 11, 22, 55, 44};
10 int max = getMax(arr);
11 System.out.println(max);
12 }
13
14 /*
15 * 获取数组中的最大值
16 * 1、返回值类型int
17 * 2、参数列表int[] arr
18 */
19 public static int getMax(int[] arr) {
20 int max = arr[0];
21 for (int i = 1; i < arr.length; i++) { // 从数组的第二个元素开始遍历
22 if (max < arr[i]) { // 如果max记录的值小于数组中的元素
23 max = arr[i]; // max记录较大的元素
24 }
25 }
26 return max;
27 }
28 }
七、数组的操作4查表法
1 /*
2 * A:案例演示
3 * 数组查表法(根据键盘录入索引,查找对应星期)
4 */
5 class JavaDemo {
6 public static void main(String[] args) {
7
8 Scanner sc = new Scanner(System.in);
9 System.out.println("请输入1~7的数字");
10 int i = sc.nextInt();
11 System.out.println("星期" + getWeek(i));
12 }
13
14 /*
15 * 根据索引返回对应的星期
16 * 1、返回值类型char
17 * 2、参数列表int week
18 */
19 public static char getWeek(int week) {
20 char[] arr = {' ', '一', '二', '三', '四', '五', '六', '日'}; // 定义了一张星期表
21 return arr[week];
22 }
23 }
八、数组的操作5基本查找
1 /*
2 * A:案例演示
3 * 数组元素查找(查找指定元素第一次在数组中出现的索引)
4 */
5 class JavaDemo {
6 public static void main(String[] args) {
7 int[] arr = {11, 22, 33, 44, 55, 66, 77, 88};
8 int index = getIndex(arr, 88);
9 System.out.println(index);
10 }
11
12 /*
13 * 查找元素索引
14 * 1、返回值类型int
15 * 2、参数列表int[] arr, int value
16 */
17 public static int getIndex(int[] arr, int value) {
18 for (int i = 0; i < arr.length; i++) {
19 if (arr[i] == value) {
20 return i;
21 }
22 }
23 return -1;
24 }
25 }
九、二维数组概述和格式1的讲解
二维数组概述：
- 二维数组格式1
- int[][] arr = new int[3][2];
- 二维数组格式1的解释
- 注意事项
- 以下格式也可以表示二维数组
- 数据类型 数组名[][] = new 数据类型[m][n];
- 数据类型[] 数组名[] = new 数据类型[m][n];
- 注意下面定义的区别
- int x;
- int y;
- int x,y;
- int[] x;
- int[] y[];
- int[] x,y[]; x是一维数组,y是二维数组
1 /*
2 * A:二维数组概述
3 * B:二维数组格式1
4 * int[][] arr = new int[3][2];
5 * C:二维数组格式1的解释
6 * D:注意事项
7 * a:以下格式也可以表示二维数组
8 * 1:数据类型 数组名[][] = new 数据类型[m][n];
9 * 2:数据类型[] 数组名[] = new 数据类型[m][n];
10 * B:注意下面定义的区别
11 *
12 int x;
13 int y;
14 int x,y;
15
16 int[] x;
17 int[] y[];
18
19 int[] x,y[]; x是一维数组,y是二维数组
20 * E:案例演示
21 * 定义二维数组，输出二维数组名称，一维数组名称，一个元素
22 */
23 class JavaDemo {
24 public static void main(String[] args) {
25 /*
26 * 这是一个二维数组
27 * 这个二维数组中有3个一维数组
28 * 每个一维数组有2个元素
29 */
30 int[][] arr = new int[3][2];
31 System.out.println(arr); // 二维数组
32 System.out.println(arr[0]); // 二维数组中的第一个一维数组
33 System.out.println(arr[0][0]); // 二维数组中的第一个一维数组的第一个元素
34 /*
35 * [[I@15db9742 // 二维数组的地址值
36 * [I@6d06d69c // 一维数组的地址值
37 * 0 // 二维数组的元素值
38 */
39 }
40 }
十、二维数组格式1的内存图解
十一、二维数组格式2的讲解及其内存图解
1 /*
2 * A:二维数组格式2
3 * int[][] arr = new int[3][];
4 * B:二维数组格式2的解释
5 * C:案例演示
6 * 讲解格式，输出数据，并画内存图
7 */
8 class JavaDemo {
9 public static void main(String[] args) {
10 int[][] arr = new int[3][]; // 这是一个二维数组，这个二维数组有三个一维数组，三个一维数组都没有赋值
11
12 System.out.println(arr[0]);
13 System.out.println(arr[1]);
14 System.out.println(arr[2]);
15 arr[0] = new int[3]; // 第一个一维数组可以存储3个int值
16 arr[1] = new int[5]; // 第e二个一维数组可以存储5个int值
17 System.out.println("-------------");
18 System.out.println(arr[0]);
19 System.out.println(arr[1]);
20 System.out.println(arr[2]);
21
22 }
23 }
十二、二维数组格式3的讲解及其内存图解
二维数组格式3：
- int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
1 /*
2 * A:二维数组格式3
3 * int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
4 * B:二维数组格式3的解释
5 * C:案例演示
6 * 讲解格式，输出数据，并画内存图
7 */
8 class JavaDemo {
9 public static void main(String[] args) {
10 int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; // 这是一个二维数组，这个二维数组中每个大括号都代表一个一维数组
11 System.out.println(arr); // [[I@15db9742，二维数组的地址值
12 System.out.println(arr[0]); // [I@6d06d69c，一维数组的地址值
13 System.out.println(arr[0][0]); // 1，一维数组中的元素值
14 }
15 }
十三、二维数组练习1遍历
1 /*
2 * A:案例演示
3 * 需求：二维数组遍历
4 * 外循环控制的是二维数组的长度，其实就是一维数组的个数。
5 * 内循环控制的是一维数组的长度。
6 */
7 class JavaDemo {
8 public static void main(String[] args) {
9 int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; // 这是一个二维数组，这个二维数组中每个大括号都代表一个一维数组
10 for (int i = 0; i < arr.length; i++) { // 获取到每个二维数组中的一维数组
11 for (int j = 0; j < arr[i].length; j++) {
12 System.out.print(arr[i][j]);
13 }
14 System.out.println();
15 }
16 }
17 }
十四、二维数组练习2求和
1 /*
2 * A:案例演示
3 *
4 需求：公司年销售额求和
5 某公司按照季度和月份统计的数据如下：单位(万元)
6 第一季度：22,66,44
7 第二季度：77,33,88
8 第三季度：25,45,65
9 第四季度：11,66,99
10 */
11 class JavaDemo {
12 public static void main(String[] args) {
13 int[][] arr = {{22, 66, 44},{77, 33, 88},{25, 45, 65}, {11, 66, 99}};
14
15 int sum = 0; // 定义变量，记录每次相加的结果
16 for (int i = 0; i < arr.length; i++) { // 获取到每个二维数组中的一维数组
17 for (int j = 0; j < arr[i].length; j++) { // 获取每一个一维数组中的元素
18 sum += arr[i][j]; // 累加
19 }
20 System.out.println(sum);
21 }
22 }
23 }
十五、思考题Java中的参数传递问题及图解
1 /*
2 * 基本数据类型的值传递，不改变原值，因为调用后就会弹栈，局部变量随之消失
3 * 引用数据类型的值传递，改变原值，因为即使方法弹栈，但是堆内存数组对象还在，可以通过地址继续访问
4 *
5 * Java到底是传值还是传址
6 * 1、既是传值，也是传地址，基本数据类型传的是值，引用数据类型传递的是地址
7 * 2、Java中只有值，因为地址值也是值（推荐这个）
8 */
9 class JavaDemo {
10 public static void main(String[] args) {
11 /*
12 int a = 10;
13 int b = 20;
14 System.out.println("a:"+a+",b:"+b); // a = 10; b = 20
15 change(a,b);
16 System.out.println("a:"+a+",b:"+b); // ? a = 10, b = 20
17 */
18 int[] arr = {1,2,3,4,5};
19 change(arr); // 得到arr = {1,4,3,8,5};
20 System.out.println(arr[1]);
21 }
22 public static void change(int a,int b) { // a = 10, b = 20
23 System.out.println("a:"+a+",b:"+b); // a = 10, b = 20
24 a = b; // a = 20
25 b = a + b; // b = 40
26 System.out.println("a:"+a+",b:"+b); // a = 20, b = 40
27 }
28 public static void change(int[] arr) { // 1, 2, 3, 4, 5
29 for(int x=0; x<arr.length; x++) {
30 if(arr[x]%2==0) {
31 arr[x]*=2;
32 }
33 }
34 }
35 }
十六、稀疏数组
稀疏数组：当一个数组中大部分元素为0，或者为同一值的时候，可以使用稀疏数组来保存数组。
稀疏数组的处理方式：
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值的元素和行列记录在一个小规模的数组中，从而缩小程序的规模。
- 如图：左边原始数组，右边稀疏数组
1 package com.sujian.array;
2 public class SparseArray {
3 public static void main(String[] args) {
4 /*
5 - - - - - - - - - - - -
6 - 0 0 0 0 0 0 0 0 0 0 0
7 - 0 0 1 0 0 0 0 0 0 0 0
8 - 0 0 0 2 0 0 0 0 0 0 0
9 - 0 0 0 0 0 0 0 0 0 0 0
10 - 0 0 0 0 0 0 0 0 0 0 0
11 - 0 0 0 0 0 0 0 0 0 0 0
12 - 0 0 0 0 0 0 0 0 0 0 0
13 - 0 0 0 0 0 0 0 0 0 0 0
14 - 0 0 0 0 0 0 0 0 0 0 0
15 - 0 0 0 0 0 0 0 0 0 0 0
16 - 0 0 0 0 0 0 0 0 0 0 0
17 */
18 // 1、创建一个二维数组 11* 11 0：没有棋子，1：黑棋，2：白棋
19 int[][] array1 = new int[11] [11];
20 array1[1][2] = 1;
21 array1[2][3] = 2;
22
23
24 // 2、输出原始数组
25 System.out.println("输出原始数组");
26
27
28 for (int[] ints : array1) {
29 for (int anInt : ints) {
30 System.out.print(anInt + "\t" );
31 }
32 System.out.println();
33 }
34 System.out.println("=====转换为稀疏数组后=====");
35 // 转化为稀疏数组来保存
36 // 1、获取有效值的个数
37 int sum = 0;
38 for (int i = 0; i < 11; i++) {
39 for (int j = 0; j < 11; j++) {
40 if (array1[i][j] != 0) {
41 sum++;
42 }
43 }
44 }
45 System.out.println("有效值的个数：" + sum);
46
47
48 // 2、创建一个稀疏数组
49 int array2[][] = new int[sum + 1][3];
50 array2[0][0] = 11;
51 array2[0][1] = 11;
52 array2[0][2] = sum;
53
54
55 // 3、遍历二维数组，将非零的值，存放到稀疏数组中
56 int count = 0;
57 for (int i = 0; i < array1.length; i++) {
58 for (int j = 0; j < array1[i].length; j++) {
59 if (array1[i][j] != 0) {
60 count++;
61 array2[count][0] = i;
62 array2[count][1] = j;
63 array2[count][2] = array1[i][j];
64 }
65
66
67 }
68 }
69
70
71 // 4、输出稀疏数组
72 System.out.println("输出稀疏数组");
73 for (int i = 0; i < array2.length; i++) {
74 for (int j = 0; j < 3; j++) {
75 System.out.print(array2[i][j] + "\t" );
76 }
77 System.out.println();
78 }
79
80
81 System.out.println("==========");
82 System.out.println("还原稀疏数组");
83 // 1、读取稀疏数组
84 int[][] array3 = new int[array2[0][0]][array2[0][1]];
85
86
87 // 2、给其中的元素还原他的值
88 for (int i = 1; i < array2.length; i++) {
89 array3[array2[i][0]][array2[i][1]] = array2[i][2];
90 }
91 // 3、输出还原数组
92 System.out.println("输出还原后的数组");
93
94
95 for (int[] ints : array3) {
96 for (int anInt : ints) {
97 System.out.print(anInt + "\t" );
98 }
99 System.out.println();
100 }
101 }
102 }