JavaSE_第4章 数组

今日内容

  • 数组概念
  • 数组的声明和初始化
  • 数组的索引
  • 数组的长度
  • 数组的遍历
  • 数组内存
  • 数组的相关算法

学习目标

  • 理解数组作为容器的概念
  • 掌握数组的声明和初始化
  • 使用索引访问数组的元素
  • 了解数组的内存图解
  • 避免空指针和越界异常
  • 掌握数组的遍历
  • 掌握常见的数组算法

第四章 数组

4.1 容器概述

案例分析

现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。假设该公司有50名员工,用前面所学的知识,程序首先需要声明50个变量来分别记住每位员工的工资,然后在进行操作,这样做会显得很麻烦,而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中,统一操作。

容器概念

  • 容器:是将多个数据存储到一起,每个数据称为该容器的元素。
  • 生活中的容器:水杯,衣柜,教室

4.2 数组的概念

  • 数组概念: 数组就是用于存储数据的长度固定的容器,保证多个数据的数据类型要一致。

百度百科中对数组的定义:

所谓数组(array),就是相同数据类型的元素按一定顺序排列的集合,就是把有限个类型相同的变量用一个名字命名,以便统一管理他们,然后用编号区分他们,这个名字称为数组名,编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

尚硅谷_高佳志_第4章【数组】 - 图1

数组的特点:

1、数组的长度一旦确定就不能修改

2、创建数组时会在内存中开辟一整块连续的空间。

3、存取元素的速度快,因为可以通过[下标],直接定位到任意一个元素。

4.3 数组的声明与初始化

数组的声明:

  1. //推荐
  2. 元素的数据类型[] 一维数组的名称;
  3. //不推荐
  4. 元素的数据类型 一维数组名[];

方式一:静态初始化

  • 格式:
  1. 数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成,不能分开两个语句写
  • 举例:

定义存储1,2,3,4,5整数的数组容器

  1. int[] arr = {1,2,3,4,5};//正确
  2. int[] arr;
  3. arr = {1,2,3,4,5};//错误

方式二:静态初始化

  • 格式:
  1. 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
  2. 数据类型[] 数组名;
  3. 数组名 = new 数据类型[]{元素1,元素2,元素3...};
  • 举例:

定义存储1,2,3,4,5整数的数组容器。

  1. int[] arr = new int[]{1,2,3,4,5};//正确
  2. int[] arr;
  3. arr = new int[]{1,2,3,4,5};//正确
  4. int[] arr = new int[5]{1,2,3,4,5};//错误的,后面有{}指定元素列表,就不需要在[长度]指定长度。

方式三:动态初始化

  • 格式:
  1. 数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
  2. 数组存储的数据类型[] 数组名字;
  3. 数组名字 = new 数组存储的数据类型[长度];
  • 数组定义格式详解:

    • 数组存储的元素的数据类型: 创建的数组容器可以存储什么数据类型的数据。
    • 元素的类型可以是任意的Java的数据类型。例如:int, String, Student等
    • [] : 表示数组。
    • 数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组。
    • new:关键字,创建数组使用的关键字。因为数组本身是引用数据类型,所以要用new创建数组对象。
    • [长度]:数组的长度,表示数组容器中可以存储多少个元素。
    • 注意:数组有定长特性,长度一旦指定,不可更改。

      • 和水杯道理相同,买了一个2升的水杯,总容量就是2升,不能多也不能少。
  • 举例:

定义可以存储5个整数的数组容器,代码如下:

  1. int[] arr = new int[5];
  2. int[] arr;
  3. arr = new int[5];

思考:用这种方式初始化的数组,元素有值吗?

4.4 数组元素的访问

  • 索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引(index),可以通过数组的索引访问到数组中的元素。
  • 索引范围:[0, 数组的长度-1]
  • 格式:
  1. 数组名[索引]
  • 索引访问数组中的元素:

    • 数组名[索引]=数值,为数组中的元素赋值
    • 变量=数组名[索引],获取出数组中的元素
  1. public static void main(String[] args) {
  2. //定义存储int类型数组,赋值元素1,2,3,4,5
  3. int[] arr = {1,2,3,4,5};
  4. //为0索引元素赋值为6
  5. arr[0] = 6;
  6. //获取数组0索引上的元素
  7. int i = arr[0];
  8. System.out.println(i);
  9. //直接输出数组0索引元素
  10. System.out.println(arr[0]);
  11. }

4.5 数组的遍历

  • 数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为:数组名.length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数组的最大索引值为数组名.length-1
  • 数组遍历: 就是将数组中的每个元素分别获取出来,就是遍历。遍历也是数组操作中的基石。
  1. public static void main(String[] args) {
  2. int[] arr = new int[]{1,2,3,4,5};
  3. //打印数组的属性,输出结果是5
  4. System.out.println("数组的长度:" + arr.length);
  5. //遍历输出数组中的元素
  6. System.out.println("数组的元素有:");
  7. for(int i=0; i<arr.length; i++){
  8. System.out.println(arr[i]);
  9. }
  10. }

4.6 数组元素的默认值

当我们使用动态初始化创建数组时:

  1. 数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];

此时只确定了数组的长度,那么数组的元素是什么值呢?

数组的元素有默认值:

尚硅谷_高佳志_第4章【数组】 - 图2

4.7 数组内存图

4.7.1 内存概述

内存是计算机中重要的部件之一,它是与CPU进行沟通的桥梁。其作用是用于暂时存放CPU中的运算数据,以及与硬盘等外部存储器交换的数据。只要计算机在运行中,CPU就会把需要运算的数据调到内存中进行运算,当运算完成后CPU再将结果传送出来。我们编写的程序是存放在硬盘中的,在硬盘中的程序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。

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

4.7.2 Java虚拟机的内存划分

为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

尚硅谷_高佳志_第4章【数组】 - 图3

区域名称 作用
程序计数器 程序计数器是CPU中的寄存器,它包含每一个线程下一条要执行的指令的地址
本地方法栈 当程序中调用了native的本地方法时,本地方法执行期间的内存区域
方法区 存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
堆内存 存储对象(包括数组对象),new来创建的,都存储在堆内存。
虚拟机栈 用于存储正在执行的每个Java方法的局部变量表等。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用,方法执行完,自动释放。

4.7.3 数组在内存中的存储

1、一个数组内存图

  1. public static void main(String[] args) {
  2. int[] arr = new int[3];
  3. System.out.println(arr);//[I@5f150435
  4. }

尚硅谷_高佳志_第4章【数组】 - 图4

思考:打印arr为什么是[I@5f150435,它是数组的地址吗?

答:它不是数组的地址。

问?不是说arr中存储的是数组对象的首地址吗?

答:arr中存储的是数组的首地址,但是因为数组是引用数据类型,打印arr时,会自动调用arr数组对象的toString()方法,默认该方法实现的是对象类型名@该对象的hashCode()值的十六进制值。

问?对象的hashCode值是否就是对象内存地址?

答:不一定,因为这个和不同品牌的JVM产品的具体实现有关。例如:Oracle的OpenJDK中给出了5种实现,其中有一种是直接返回对象的内存地址,但是OpenJDK默认没有选择这种方式。

2、数组下标为什么是0开始

因为第一个元素距离数组首地址间隔0个单元。

3、两个数组内存图

  1. public static void main(String[] args) {
  2. int[] arr = new int[3];
  3. int[] arr2 = new int[2];
  4. System.out.println(arr);
  5. System.out.println(arr2);
  6. }

尚硅谷_高佳志_第4章【数组】 - 图5

4、两个变量指向一个数组

  1. public static void main(String[] args) {
  2. // 定义数组,存储3个元素
  3. int[] arr = new int[3];
  4. //数组索引进行赋值
  5. arr[0] = 5;
  6. arr[1] = 6;
  7. arr[2] = 7;
  8. //输出3个索引上的元素值
  9. System.out.println(arr[0]);
  10. System.out.println(arr[1]);
  11. System.out.println(arr[2]);
  12. //定义数组变量arr2,将arr的地址赋值给arr2
  13. int[] arr2 = arr;
  14. arr2[1] = 9;
  15. System.out.println(arr[1]);
  16. }

尚硅谷_高佳志_第4章【数组】 - 图6

4.8 数组的练习题

1、练习1:用一个数组存储26个小写英文字母,并遍历显示,显示要求如:a->A

2、练习2:用一个数组存储本组学员的年龄,从键盘输入,并遍历显示

3、练习3:用一个数组存储本组4个学员的姓名,从键盘输入,并遍历显示

4、练习4:用数组存储一个星期的7个英文单词,然后从键盘输入星期的值[1-7],输出对应的英文单词

  1. Monday Tuesday Wednesday Thursday Friday Saturday Sunday

4.9 数组的常见算法

4.9.1 数组统计:求总和、均值、统计偶数个数等

思路:遍历数组,挨个的累加,判断每一个元素

示例代码:

  1. int[] arr = {4,5,6,1,9};
  2. //求总和、均值
  3. int sum = 0;//因为0加上任何数都不影响结果
  4. for(int i=0; i<arr.length; i++){
  5. sum += arr[i];
  6. }
  7. double avg = (double)sum/arr.length;

示例代码2:

  1. int[] arr = {4,5,6,1,9};
  2. //求总乘积
  3. long result = 1;//因为1乘以任何数都不影响结果
  4. for(int i=0; i<arr.length; i++){
  5. result *= arr[i];
  6. }

示例代码3:

  1. int[] arr = {4,5,6,1,9};
  2. //统计偶数个数
  3. int even = 0;
  4. for(int i=0; i<arr.length; i++){
  5. if(arr[i]%2==0){
  6. even++;
  7. }
  8. }

4.9.2 数组的顺序查找

顺序查找:挨个查看

要求:对数组元素的顺序没要求

顺序查找示例代码:

  1. //查找value第一次在数组中出现的index
  2. public static void main(String[] args){
  3. int[] arr = {4,5,6,1,9};
  4. int value = 1;
  5. int index = -1;
  6. for(int i=0; i<arr.length; i++){
  7. if(arr[i] == value){
  8. index = i;
  9. break;
  10. }
  11. }
  12. if(index==-1){
  13. System.out.println(value + "不存在");
  14. }else{
  15. System.out.println(value + "的下标是" + index);
  16. }
  17. }

4.9.3 数组找最值

尚硅谷_高佳志_第4章【数组】 - 图7

思路:

(1)先假设第一个元素最大/最小

(2)然后用max/min与后面的元素一一比较

示例代码:

  1. int[] arr = {4,5,6,1,9};
  2. //找最大值
  3. int max = arr[0];
  4. for(int i=1; i<arr.length; i++){
  5. if(arr[i] > max){
  6. max = arr[i];
  7. }
  8. }

4.9.4 数组中找最值及其下标

情况一:找最值及其第一次出现的下标

思路:

(1)先假设第一个元素最大/最小

(2)用max/min变量表示最大/小值,用max/min与后面的元素一一比较

(3)用index时刻记录目前比对的最大/小的下标

示例代码:

  1. int[] arr = {4,5,6,1,9};
  2. //找最大值
  3. int max = arr[0];
  4. int index = 0;
  5. for(int i=1; i<arr.length; i++){
  6. if(arr[i] > max){
  7. max = arr[i];
  8. index = i;
  9. }
  10. }

思路:

(1)先假设第一个元素最大/最小

(2)用maxIndex时刻记录目前比对的最大/小的下标,那么arr[maxIndex]就是目前的最大值

  1. int[] arr = {4,5,6,1,9};
  2. //找最大值
  3. int maxIndex = 0;
  4. for(int i=1; i<arr.length; i++){
  5. if(arr[i] > arr[maxIndex]){
  6. maxIndex = i;
  7. }
  8. }
  9. System.out.println("最大值:" + arr[maxIndex]);

情况二:找最值及其所有最值的下标(即可能最大值重复)

思路:

(1)先找最大值

①假设第一个元素最大

②用max与后面的元素一一比较

(2)遍历数组,看哪些元素和最大值是一样的

示例代码:

  1. int[] arr = {4,5,6,1,9};
  2. //找最大值
  3. int max = arr[0];
  4. for(int i=1; i<arr.length; i++){
  5. if(arr[i] > max){
  6. max = arr[i];
  7. }
  8. }
  9. //遍历数组,看哪些元素和最大值是一样的
  10. for(int i=0; i<arr.length; i++){
  11. if(max == arr[i]){
  12. System.out.print(i+"\t");
  13. }
  14. }

4.9.5 冒泡排序

Java中的经典算法之冒泡排序(Bubble Sort)

原理:比较两个相邻的元素,将值大的元素交换至右端。

思路:依次比较相邻的两个数,将小数放到前面,大数放到后面。

  1. 即第一趟,首先比较第1个和第2个元素,将小数放到前面,大数放到后面。
  2. 然后比较第2个和第3个元素,将小数放到前面,大数放到后面。
  3. 如此继续,直到比较最后两个数,将小数放到前面,大数放到后面。
  4. 重复第一趟步骤,直至全部排序完成。
  1. 例如:冒泡:从小到大,从左到右两两比较
  2. /*
  3. {6,3,8,2,9,1}
  4. 第一轮:
  5. 第1次:arr[0]与arr[1]比较,6>3成立,就交换,{3,6,8,2,9,1}
  6. 第2次:arr[1]与arr[2]比较,6>8不成立,不交换{3,6,8,2,9,1}
  7. 第3次:arr[2]与arr[3]比较,8>2成立,就交换,{3,6,2,8,9,1}
  8. 第4次:arr[3]与arr[4]比较,8>9不成立,不交换{3,6,2,8,9,1}
  9. 第5次:arr[4]与arr[5]比较,9>1成立,就交换,{3,6,2,8,1,9}
  10. 第一轮结果:{3,6,2,8,1,9} 9已经到达正确位置,下一轮不用在参与
  11. 第二轮:
  12. 第1次:arr[0]与arr[1]比较,3>6不成立,不交换{3,6,2,8,1,9}
  13. 第2次:arr[1]与arr[2]比较,6>2成立,就交换,{3,2,6,8,1,9}
  14. 第3次:arr[2]与arr[3]比较,6>8不成立,不交换{3,2,6,8,1,9}
  15. 第4次:arr[3]与arr[4]比较,8>1成立,就交换,{3,2,6,1,8,9}
  16. 第二轮结果:{3,2,6,1,8,9} 8已经到达正确位置,下一轮不用在参与
  17. 第三轮:
  18. 第1次:arr[0]与arr[1]比较,3>2成立,就交换,{2,3,6,1,8,9}
  19. 第2次:arr[1]与arr[2]比较,3>6不成立,不交换{2,3,6,1,8,9}
  20. 第3次:arr[2]与arr[3]比较,6>1成立,就交换,{2,3,1,6,8,9}
  21. 第三轮结果:{2,3,1,6,8,9} 6已经到达正确位置,下一轮不用在参与
  22. 第四轮:
  23. 第1次:arr[0]与arr[1]比较,2>3不成立,不交换{2,3,1,6,8,9}
  24. 第2次:arr[1]与arr[2]比较,3>1成立,就交换,{2,1,3,6,8,9}
  25. 第四轮结果:{2,1,3,6,8,9} 3已经到达正确位置,下一轮不用在参与
  26. 第五轮
  27. 第1次:arr[0]与arr[1]比较,2>1成立,就交换,{1,2,3,6,8,9}
  28. 第五轮结果:{1,2,3,6,8,9} 2已经到达正确位置,下一轮不用在参与
  29. 剩下1,肯定是最小的了,不用比较了
  30. 6个元素,比较了5轮, n个元素需要n-1轮
  31. 每一轮比较很多次
  32. */

示例代码:

  1. public static void main(String[] args){
  2. int[] arr = {6,3,8,2,9,1}; //arr.length = 6
  3. //i=1,2,3,4,5 一共5轮
  4. for(int i=1; i<arr.length; i++){//轮数
  5. /*
  6. i=1,第1轮,j=0,1,2,3,4 arr[j]与arr[j+1]
  7. i=2,第2轮,j=0,1,2,3 arr[j]与arr[j+1]
  8. i=3,第3轮,j=0,1,2 arr[j]与arr[j+1]
  9. i=4,第4轮,j=0,1 arr[j]与arr[j+1]
  10. i=5,第5轮,j=0 arr[j]与arr[j+1]
  11. j=0, j<=arr.length-1-i
  12. */
  13. for(int j=0; j<=arr.length-1-i; j++){
  14. if(arr[j] > arr[j+1]){
  15. int temp = arr[j];
  16. arr[j] = arr[j+1];
  17. arr[j+1] = temp;
  18. }
  19. }
  20. }
  21. //结果
  22. for(int i=0; i<arr.length; i++){
  23. System.out.print(arr[i] + " ");
  24. }
  25. }

示例代码:从大到小,从右到左

  1. char[] arr = {'h','e','l','l','o','j','a','v','a'};
  2. for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
  3. /*
  4. 第1轮,i=1,从右到左两两比较,arr[8]与arr[7],arr[7]与arr[6]....arr[1]与arr[0]
  5. 第2轮,i=2,从右到左两两比较,arr[8]与arr[7],arr[7]与arr[6]....arr[2]与arr[1]
  6. ...
  7. 第8轮,i=8,从右到左两两比较,arr[8]与arr[7]
  8. arr[j]与arr[j-1]
  9. 找两个关键点:(1)j的起始值:8(2)找j的终止值,依次是1,2,3,。。。8,得出j>=i
  10. */
  11. for(int j=8; j>=i; j--){
  12. //从大到小,后面的元素 > 前面的元素,就交换
  13. if(arr[j]>arr[j-1]){
  14. int temp = arr[j];
  15. arr[j] = arr[j-1];
  16. arr[j-1] = temp;
  17. }
  18. }
  19. }

4.9.6 练习

1、随机产生10个[0,100)之间整数,统计3的倍数的个数

2、随机产生10个[0,150)之间整数,统计既是3又是5,但不是7的倍数的个数

3、随机产生10个[0,100)之间整数,统计素数的个数

4、已知本组学员有:String[] names = {“张三”,”李四”,”王五”,”赵六”,”钱七”};,从键盘输入一个学生姓名,查看他是否是本组学员

5、声明两个数组,一个存储本组学员姓名,一个存储本组学员成绩,找出最高分同学的姓名

4.10 二维数组

  • 二维数组:本质上就是元素为一维数组的一个数组。

  • 二维数组的标记:[][]

  1. int[][] arr; //arr是一个二维数组,可以看成元素是int[]一维数组类型的一个数组

二维数组也可以看成一个二维表,行*列组成的二维表,只不过这个二维表,每一行的列数还可能不同。但是每一个单元格中的元素的数据类型是一致的,例如:都是int,都是String等

尚硅谷_高佳志_第4章【数组】 - 图8

4.10.1 二维数组的声明与初始化

语法格式:

  1. //推荐
  2. 元素的数据类型[][] 二维数组的名称;
  3. //不推荐
  4. 元素的数据类型 二维数组名[][];
  5. //不推荐
  6. 元素的数据类型[] 二维数组名[];

面试:

  1. int[] x, y[];
  2. //x是一维数组,y是二维数组

1、静态初始化

  1. 元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
  2. {元素1,元素2,元素3 。。。},
  3. {第二行的值列表},
  4. ...
  5. {第n行的值列表}
  6. };
  7. 元素的数据类型[][] 二维数组名;
  8. 二维数组名 = new 元素的数据类型[][]{
  9. {元素1,元素2,元素3 。。。},
  10. {第二行的值列表},
  11. ...
  12. {第n行的值列表}
  13. };
  14. //以下格式要求声明与静态初始化必须一起完成
  15. 元素的数据类型[][] 二维数组的名称 = {
  16. {元素1,元素2,元素3 。。。},
  17. {第二行的值列表},
  18. ...
  19. {第n行的值列表}
  20. };

如果是静态初始化,右边new 数据类型[][]中不能写数字,因为行数和列数,由{}的元素个数决定

举例:

  1. int[][] arr;
  2. arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
  3. arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};//错误,静态初始化右边new 数据类型[]中不能写数字
  4. int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
  5. int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};//声明与初始化必须在一句完成
  1. public class Array2Demo1 {
  2. public static void main(String[] args) {
  3. //定义数组
  4. int[][] arr = {{1,2,3},{4,5},{6}};
  5. System.out.println(arr);
  6. System.out.println(arr[0]);
  7. System.out.println(arr[1]);
  8. System.out.println(arr[2]);
  9. System.out.println(arr[0][0]); //1
  10. System.out.println(arr[1][0]); //4
  11. System.out.println(arr[2][0]); //6
  12. System.out.println(arr[0][1]); //2
  13. System.out.println(arr[1][1]); //5
  14. //越界
  15. System.out.println(arr[2][1]); //错误
  16. }
  17. }

2、动态初始化(规则二维表:每一行的列数是相同的)

  1. //(1)确定行数和列数
  2. 元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
  3. m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
  4. n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
  5. //此时创建完数组,行数、列数确定,而且元素也都有默认值
  6. //(2)再为元素赋新值
  7. 二维数组名[行下标][列下标] = 值;
  1. public static void main(String[] args) {
  2. //定义一个二维数组
  3. int[][] arr = new int[3][2];
  4. //定义了一个二维数组arr
  5. //这个二维数组有3个一维数组的元素
  6. //每一个一维数组有2个元素
  7. //输出二维数组名称
  8. System.out.println(arr); //地址值 [[I@175078b
  9. //输出二维数组的第一个元素一维数组的名称
  10. System.out.println(arr[0]); //地址值 [I@42552c
  11. System.out.println(arr[1]); //地址值 [I@e5bbd6
  12. System.out.println(arr[2]); //地址值 [I@8ee016
  13. //输出二维数组的元素
  14. System.out.println(arr[0][0]); //0
  15. System.out.println(arr[0][1]); //0
  16. //...
  17. }

3、动态初始化(不规则:每一行的列数可能不一样)

  1. //(1)先确定总行数
  2. 元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
  3. //此时只是确定了总行数,每一行里面现在是null
  4. //(2)再确定每一行的列数,创建每一行的一维数组
  5. 二维数组名[行下标] = new 元素的数据类型[该行的总列数];
  6. //此时已经new完的行的元素就有默认值了,没有new的行还是null
  7. //(3)再为元素赋值
  8. 二维数组名[行下标][列下标] = 值;
  1. public static void main(String[] args) {
  2. //定义数组
  3. int[][] arr = new int[3][];
  4. System.out.println(arr); //[[I@175078b
  5. System.out.println(arr[1][0]);//NullPointerException
  6. System.out.println(arr[0]); //null
  7. System.out.println(arr[1]); //null
  8. System.out.println(arr[2]); //null
  9. //动态的为每一个一维数组分配空间
  10. arr[0] = new int[2];
  11. arr[1] = new int[3];
  12. arr[2] = new int[1];
  13. System.out.println(arr[0]); //[I@42552c
  14. System.out.println(arr[1]); //[I@e5bbd6
  15. System.out.println(arr[2]); //[I@8ee016
  16. System.out.println(arr[0][0]); //0
  17. System.out.println(arr[0][1]); //0
  18. //ArrayIndexOutOfBoundsException
  19. //System.out.println(arr[0][2]); //错误
  20. arr[1][0] = 100;
  21. arr[1][2] = 200;
  22. }

4.10.2 二维数组的相关名称及其表示方式

(1)二维数组的长度/行数:

  1. 二维数组名.length

(2)二维数组的某一行:

  1. 二维数组名[行下标]
  2. 行下标的范围:[0, 二维数组名.length-1]

(3)某一行的列数:

  1. 二维数组名[行下标].length
  2. 因为二维数组的每一行是一个一维数组

(4)某一个元素

  1. 二维数组名[行下标][列下标]

4.10.3 二维数组的遍历

  1. for(int i=0; i<二维数组名.length; i++){
  2. for(int j=0; j<二维数组名[i].length; j++){
  3. System.out.print(二维数组名[i][j]);
  4. }
  5. System.out.println();
  6. }

4.10.4 数组操作的常见异常

1 数组越界异常

观察一下代码,运行后会出现什么结果。

  1. public static void main(String[] args) {
  2. int[] arr = {1,2,3};
  3. System.out.println(arr[3]);
  4. }

创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修改我们编写的代码。

尚硅谷_高佳志_第4章【数组】 - 图9

2 数组空指针异常

观察一下代码,运行后会出现什么结果。

  1. public static void main(String[] args) {
  2. //定义数组
  3. int[][] arr = new int[3][];
  4. System.out.println(arr[0][0]);//NullPointerException
  5. }

因为此时数组的每一行还未分配具体存储元素的空间,此时arr[0]是null,此时访问arr[0][0]会抛出NullPointerException 空指针异常。

尚硅谷_高佳志_第4章【数组】 - 图10

空指针异常在内存图中的表现

尚硅谷_高佳志_第4章【数组】 - 图11

4.10.5 二维数组练习

1、练习1

1、请使用二维数组存储如下数据,并遍历显示

1

2 2

3 3 3

4 4 4 4

5 5 5 5 5

  1. public static void main(String[] args){
  2. //1、声明一个二维数组,并且确定行数
  3. //因为每一行的列数不同,这里无法直接确定列数
  4. int[][] arr = new int[5][];
  5. //2、确定每一行的列数
  6. for(int i=0; i<arr.length; i++){
  7. /*
  8. arr[0] 的列数是1
  9. arr[1] 的列数是2
  10. arr[2] 的列数是3
  11. arr[3] 的列数是4
  12. arr[4] 的列数是5
  13. */
  14. arr[i] = new int[i+1];
  15. }
  16. //3、确定元素的值
  17. for(int i=0; i<arr.length; i++){
  18. for(int j=0; j<arr[i].length; j++){
  19. arr[i][j] = i+1;
  20. }
  21. }
  22. //4、遍历显示
  23. for(int i=0; i<arr.length; i++){
  24. for(int j=0; j<arr[i].length; j++){
  25. System.out.print(arr[i][j] + " ");
  26. }
  27. System.out.println();
  28. }
  29. }
  1. public static void main(String[] args){
  2. //1、声明一个二维数组,并且初始化
  3. int[][] arr = {
  4. {1},
  5. {2,2},
  6. {3,3,3},
  7. {4,4,4,4},
  8. {5,5,5,5,5}
  9. };
  10. //2、遍历显示
  11. for(int i=0; i<arr.length; i++){
  12. for(int j=0; j<arr[i].length; j++){
  13. System.out.print(arr[i][j] + " ");
  14. }
  15. System.out.println();
  16. }
  17. }
  1. public static void main(String[] args){
  2. //1、声明一个二维数组,并且确定行数
  3. //因为每一行的列数不同,这里无法直接确定列数
  4. int[][] arr = new int[5][];
  5. for(int i=0; i<arr.length; i++){
  6. //2、确定每一行的列数
  7. arr[i] = new int[i+1];
  8. //3、确定元素的值
  9. for(int j=0; j<arr[i].length; j++){
  10. arr[i][j] = i+1;
  11. System.out.print(arr[i][j] + " ");
  12. }
  13. System.out.println();
  14. }
  15. }

2、练习2

2、请使用二维数组存储如下数据,并遍历显示

1 1 1 1 1

2 2 2 2 2

3 3 3 3 3

4 4 4 4 4

  1. public static void main(String[] args){
  2. int[][] arr = {
  3. {1,1,1,1,1},
  4. {2,2,2,2,2},
  5. {3,3,3,3,3},
  6. {4,4,4,4,4}
  7. };
  8. for(int i=0; i<arr.length; i++){
  9. for(int j=0; j<arr[i].length; j++){
  10. System.out.print(arr[i][j]+" ");
  11. }
  12. System.out.println();
  13. }
  14. }
  1. public static void main(String[] args) {
  2. //1、声明二维数组,并确定行数和列数
  3. int[][] arr = new int[4][5];
  4. //2、确定元素的值
  5. for (int i = 0; i < arr.length; i++) {
  6. for (int j = 0; j < arr.length; j++) {
  7. arr[i][j] = i + 1;
  8. }
  9. }
  10. //3、遍历显示
  11. for(int i=0; i<arr.length; i++){
  12. for(int j=0; j<arr[i].length; j++){
  13. System.out.print(arr[i][j] + " ");
  14. }
  15. System.out.println();
  16. }
  17. }

3、练习3

3、请使用二维数组存储如下数据,并遍历显示

  1. String[][] employees = {
  2. {"10", "1", "段誉", "22", "3000"},
  3. {"13", "2", "令狐冲", "32", "18000", "15000", "2000"},
  4. {"11", "3", "任我行", "23", "7000"},
  5. {"11", "4", "张三丰", "24", "7300"},
  6. {"12", "5", "周芷若", "28", "10000", "5000"},
  7. {"11", "6", "赵敏", "22", "6800"},
  8. {"12", "7", "张无忌", "29", "10800","5200"},
  9. {"13", "8", "韦小宝", "30", "19800", "15000", "2500"},
  10. {"12", "9", "杨过", "26", "9800", "5500"},
  11. {"11", "10", "小龙女", "21", "6600"},
  12. {"11", "11", "郭靖", "25", "7100"},
  13. {"12", "12", "黄蓉", "27", "9600", "4800"}
  14. };

其中”10”代表普通职员,”11”代表程序员,”12”代表设计师,”13”代表架构师

尚硅谷_高佳志_第4章【数组】 - 图12

  1. public static void main(String[] args) {
  2. String[][] employees = {
  3. {"10", "1", "段誉", "22", "3000"},
  4. {"13", "2", "令狐冲", "32", "18000", "15000", "2000"},
  5. {"11", "3", "任我行", "23", "7000"},
  6. {"11", "4", "张三丰", "24", "7300"},
  7. {"12", "5", "周芷若", "28", "10000", "5000"},
  8. {"11", "6", "赵敏", "22", "6800"},
  9. {"12", "7", "张无忌", "29", "10800","5200"},
  10. {"13", "8", "韦小宝", "30", "19800", "15000", "2500"},
  11. {"12", "9", "杨过", "26", "9800", "5500"},
  12. {"11", "10", "小龙女", "21", "6600"},
  13. {"11", "11", "郭靖", "25", "7100"},
  14. {"12", "12", "黄蓉", "27", "9600", "4800"}
  15. };
  16. System.out.println("员工类型\t编号\t姓名\t年龄\t薪资\t奖金\t股票\t");
  17. for (int i = 0; i < employees.length; i++) {
  18. switch(employees[i][0]){
  19. case "10":
  20. System.out.print("普通职员");
  21. break;
  22. case "11":
  23. System.out.print("程序员");
  24. break;
  25. case "12":
  26. System.out.print("设计师");
  27. break;
  28. case "13":
  29. System.out.print("架构师");
  30. break;
  31. }
  32. for (int j = 1; j < employees[i].length; j++) {
  33. System.out.print("\t" + employees[i][j]);
  34. }
  35. System.out.println();
  36. }
  37. }

4.10.6 二维数组的内存图分析

1、示例一

  1. int[][] arr = {
  2. {1},
  3. {2,2},
  4. {3,3,3},
  5. {4,4,4,4},
  6. {5,5,5,5,5}
  7. };

尚硅谷_高佳志_第4章【数组】 - 图13

2、示例二

  1. //1、声明二维数组,并确定行数和列数
  2. int[][] arr = new int[4][5];
  3. //2、确定元素的值
  4. for (int i = 0; i < arr.length; i++) {
  5. for (int j = 0; j < arr.length; j++) {
  6. arr[i][j] = i + 1;
  7. }
  8. }

尚硅谷_高佳志_第4章【数组】 - 图14

3、示例三

  1. //1、声明一个二维数组,并且确定行数
  2. //因为每一行的列数不同,这里无法直接确定列数
  3. int[][] arr = new int[5][];
  4. //2、确定每一行的列数
  5. for(int i=0; i<arr.length; i++){
  6. /*
  7. arr[0] 的列数是1
  8. arr[1] 的列数是2
  9. arr[2] 的列数是3
  10. arr[3] 的列数是4
  11. arr[4] 的列数是5
  12. */
  13. arr[i] = new int[i+1];
  14. }
  15. //3、确定元素的值
  16. for(int i=0; i<arr.length; i++){
  17. for(int j=0; j<arr[i].length; j++){
  18. arr[i][j] = i+1;
  19. }
  20. }

尚硅谷_高佳志_第4章【数组】 - 图15