200-Java语言基础-Java编程入门-006 | Java数组定义及使用（引用数据类型）

一、数组概述和定义格式说明

为什么要有数组（容器）：

• 为了存储同种数据类型的多个值

数组概念：

• 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
• 数组既可以存储基本数据类型，也可以存储引用数据类型。

数组定义格式：

• 数据类型[] 数组名 = 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 }