目 录CONTENT

文章目录

从0开始学Java——数组(6)

Eric
2022-01-23 / 0 评论 / 0 点赞 / 163 阅读 / 6,820 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2023-12-12,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

1 容器概述

1.1 案例分析

  • 现在需要统计某公司员工的工资情况,例如:计算平均工资、找到最高工资。假设该公司有50名员工,用前面所学的只是,程序首先需要声明50个变量来分别记住每位员工的工资,然后再进行操作,这样会显得很麻烦,而且错误率也很高。

  • 因此,我们可以使用容器来进行操作。将所有的数据全部存储到一个容器中,统一进行操作。

1.2 容器概念

  • 容器:是将多个数据存储到一起,每个数据称为容器中的元素。

  • 生活中的容器:水杯、衣柜、教室……

2 数组简介

2.1 数组的概念

  • 数组的概念:相同类型数据的有序集合。

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

img

2.2 数组的特点

  • 数组的长度一旦确定不能修改。

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

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

3 数组的声明和初始化

3.1 数组的声明

  • 语法:
数据类型[] 数组名;
// 不推荐
数组类型 数组[];
  • 示例:
/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 数组的声明
        int[] arr ;
    }
}

3.2 静态初始化

3.2.1 语法1

  • 语法:
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成,不能分开两个语句写
  • 示例:
/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 数组的静态初始化
        int[] arr = {1, 2, 3};
    }
}

3.2.2 语法2

  • 语法:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};
  • 示例:
/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 数组的静态初始化
        int[] arr = new int[]{1, 2, 3};
    }
}
  • 示例:
/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 数组的静态初始化
        int[] arr;
        arr = new int[]{1, 2, 3};
    }
}

3.3 动态初始化

  • 语法:
数据类型[] 数组名= new 数据类型[长度];
 数据类型[] 数组名;
 数组名 = new 数据类型[长度];
  • 示例:
/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 数组的动态初始化
        int[] arr = new int[5];

    }
}

4 数组元素的访问

  • 索引(下标):每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编码就称为数组的索引(index),可以通过数组的索引访问到数组中的元素。

  • 索引范围:[0,数组的长度-1]。

  • 语法:

数组名[索引]
  • 索引访问数组中的元素:

    • 数组名[索引]=值,为数组中的元素赋值。
    • 变量名=数组名[索引],获取数组中的元素。
  • 示例:

/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 19:48
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        // 定义一个int类型的数组
        int[] arr = {1, 2, 3, 4, 5, 6};
        // 为索引为0的元素赋值
        arr[0] = 8;
        // 获取数组索引为0的元素
        int i = arr[0];
        System.out.println("i = " + i);
        // 输出数组索引为0的元素
        System.out.println(arr[0]);
    }
}

5 数组的遍历

  • 数组的长度属性:每个数组都具有长度,而且是固定的,Java中赋予了数组一个属性,可以获取到数组的长度,语法为:数组名.length,属性length的执行结果是数组的长度。由此可以推断出,数组的最大索引值为数组名.length-1

  • 数组遍历:就是将数组中的每个元素分别获取出来。

  • 示例:

/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 21:19
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        
        int[] arr = new int[]{1, 3, 5, 7, 9, 3};
        System.out.println("数组的长度:" + arr.length);
        
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[i] = " + arr[i]);
        }
    }
}

6 数组元素的默认值

  • 当我们使用动态初始化数据的时候:
数据类型[] 数组名= new 数据类型[长度];
  • 此时,只确定了数组的长度,那么数组中的元素是什么?

  • 数组的元素具有默认值:

img

7 数组内存示意图

7.1 内存概述

  • 内存是计算机中重要的部件之一,它是和CPU进行沟通的桥梁。其作用是暂时存放CPU中运算的数据,以及和硬盘等外部存储设备交换数据。只要计算机在运行中,CPU就会将需要运算的数据调到内存中进行运算,当运算完成后CPU再将结果传送出来。

  • 我们编写的程序是存放在硬盘中的,在硬盘中的程序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。

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

7.2 Java虚拟机的内存划分

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

img

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

7.3 数组在内存中的存储

7.3.1 一个数组内存图

/**
 * 一个数组内存图
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 22:02
 */
public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr); // [I@5f150435
    }
}

img

  • 问:打印arr是[I@5f150435,它是数组的地址吗?

  • 答:它不是数组的地址。

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

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

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

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

7.3.2 数组的下标为什么从0开始?

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

7.3.3 两个数组内存图

/**
 * 两个数组内存图
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 22:06
 */
public class ArrayTest4 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        int[] arr2 = new int[2];
        System.out.println(arr);
        System.out.println(arr2);
    }
}

img

7.3.4 两个变量指向同一个数组

/**
 * 两个数组指向同一个数组
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-12 22:08
 */
public class ArrayTest5 {
    public static void main(String[] args) {
        // 定义数组,存储3个元素
        int[] arr = new int[3];
        //数组索引进行赋值
        arr[0] = 5;
        arr[1] = 6;
        arr[2] = 7;
        //输出3个索引上的元素值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //定义数组变量arr2,将arr的地址赋值给arr2
        int[] arr2 = arr;
        arr2[1] = 9;
        System.out.println(arr[1]);
    }
}

img

8 数组的练习题

8.1 练习1

  • 键盘录入5个学生的成绩,求总和以及平均成绩,并显示每一个学生的成绩。

  • 示例:

import java.util.Scanner;

/**
 * 键盘录入5个学生的成绩,求总和以及平均成绩,并显示每一个学生的成绩。
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 05:41
 */
public class ArrayExercise1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // 定义数组
        double[] scores = new double[5];
        // 向数组中添加分数
        for (int i = 0; i < scores.length; i++) {
            System.out.print("请输入第" + (i + 1) + "个学生的成绩:");
            scores[i] = input.nextDouble();
        }
        // 求总和以及平均分
        double total = 0;
        for (int i = 0; i < scores.length; i++) {
            total += scores[i];
        }

        System.out.println("学生成绩的总和是:" + total);
        System.out.println("学生成绩的平均分是:" + (total / scores.length));

        // 显示每一个学生的成绩
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第" + (i + 1) + "个学生的成绩:" + scores[i]);
        }

    }
}

8.2 练习2

  • 分析以下需求,并用代码实现:

  • ①在编程竞赛中,有10位评委为参赛的选手打分,分数分别为:5,4,6,8,9,0,1,2,7,3。

  • ②求选手的最后得分(去掉一个最高分和一个最低分后其余8位评委打分的平均值)

  • 示例:

/**
 * 分析以下需求,并用代码实现:
 * ①在编程竞赛中,有10位评委为参赛的选手打分,分数分别为:5,4,6,8,9,0,1,2,7,3。
 * ②求选手的最后得分(去掉一个最高分和一个最低分后其余8位评委打分的平均值)。
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 06:00
 */
public class ArrayExercise2 {
    public static void main(String[] args) {
        // 创建数组对象用来保存评委打分成绩
        int[] scores = {5, 4, 6, 8, 9, 0, 1, 2, 7, 3};
        // 遍历数组,求最高分和最低分
        int max = scores[0];
        int min = scores[0];
        for (int i = 0; i < scores.length; i++) {
            int score = scores[i];
            if (score >= max) {
                max = score;
            }
            if (score <= min) {
                min = score;
            }
        }
        // 遍历数组,遇到最高分和最低分跳过
        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            int score = scores[i];
            /*  如果遇到最高分或最低分直接跳过累加,那么就会将所有的最高分跳过,极限情况下,如果打分都是最高分,那么所有的分数都会跳过,最终的平均分为0。这是错误的。
            if (score == max || score == min) {
                continue;
            }
            */
            total += score;
        }

        // 根据评分规则,最高分和最低分只去掉一个
        total -= max;
        total -= min;

        // 平均分
        double avg = (double) total / (scores.length - 2);
        System.out.println("选手的最后得分:" + avg);

    }
}

8.3 练习3

  • 已知:一年12个月每个月的总天数是:{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31},从键盘输入年,月,日后,计算这一天是这一年的第几天。

  • 提示:考虑闰年。

  • 示例:

import java.util.Scanner;

/**
 * 已知:一年12个月每个月的总天数是:{ 31,28,31,30,31,30,31,31,30,31,30,31},从键盘输入年,月,日后,计算这一天是这一年的第几天。
 * 提示:考虑闰年。
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 06:35
 */
public class ArrayExercise3 {
    public static void main(String[] args) {
        // 创建数组并保存每个月的天数
        int[] dayOfMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        // 创建Scanner对象
        Scanner input = new Scanner(System.in);
        System.out.print("请输入年份(四位数):");
        int year = input.nextInt();
        System.out.print("请输入月份(1~12):");
        int month = input.nextInt();
        System.out.print("请输入天(1~31):");
        int day = input.nextInt();
        // 声明一个变量用来保存天数累加的结果
        int sum = 0;
        /*
            在计算天数总和的时,分为两部分考虑:
            ① 已经经过的整月(如果用户指定的是1月,那么前面没有经过的整月)。
            ② 用户指定的当前月。
         */
        /* 通过循环计算①,假设用户输入的月份是2,那么经过的整月是1 */
        for (int i = 0; i < month - 1; i++) {
            sum += dayOfMonth[i];
        }
        /* 计算② */
        // 当前月的总天数
        int days = dayOfMonth[month - 1];
        /*
         * 如果用户输入的是2月28之前的天数(包括28号),则不需要考虑闰年
         */
        // 如果用户输入的天数 > 当前月的总天数,就按照当前月的总天数计算
        if (month == 1 || (month == 2 && day <= 28)) {
            sum += Math.min(day, days);
        } else {
            /*
             * 判断闰年
             * ①若某个年份能被4整除但不能被100整除,则是闰年。
             * ②若某个年份能被400整除,则也是闰年。
             */
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                sum++;
            }
        }
        System.out.println("sum = " + sum);
    }
}

8.4 练习4

  • 用一个数组,保存星期一到星期天的7个英语单词,从键盘输入1-7,显示对应的单词。
中文英文
星期一Monday
星期二Tuesday
星期三Wednesday
星期四Thursday
星期五Friday
星期六Saturday
星期日Sunday
  • 示例:
import java.util.Scanner;

/**
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 09:08
 */
public class ArrayExercise4 {
    public static void main(String[] args) {
        // 保存星期英文单词的数组
        String[] weeks = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
        // 创建Scanner对象
        Scanner input = new Scanner(System.in);
        System.out.print("请输入(1~7):");
        int week = input.nextInt();
        System.out.println(weeks[week - 1]);
    }
}

8.5 练习5

  • 用一个数组存储26个英文字母的小写形式,并遍历显示小写字母以及它对应的大写字母,例如:a->A

  • 示例:

/**
 * 用一个数组存储26个英文字母的小写形式,并遍历显示小写字母以及它对应的大写字母,例如:a->A
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 09:08
 */
public class ArrayExercise5 {
    public static void main(String[] args) {
        // 创建一个保存26个英文字母的小写形式的数组
        char[] chs = new char[26];
        // 数组遍历,将26个英文字母的小写保存到数组中
        for (int i = 0; i < 26; i++) {
            chs[i] = (char) (97 + i);
        }
        // 数组遍历,显示小写字母以及它对应的大写字母
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i] + "->" + (char) (chs[i] - 32));
        }
    }
}

8.6 练习6

  • 从键盘输入本组学员人数。

  • 声明两个数组,一个存储本组学员的姓名,一个存储本组学员的成绩。

  • 从键盘输入每一个人的姓名和成绩,分别存到两个数组中。

  • 找出最高分和最低分的学员的姓名。

  • 示例:

import java.util.Scanner;

/**
 * 从键盘输入本组学员人数。
 * <p>
 * 声明两个数组,一个存储本组学员的姓名,一个存储本组学员的成绩。
 * <p>
 * 从键盘输入每一个人的姓名和成绩,分别存到两个数组中。
 * <p>
 * 找出最高分和最低分的学员的姓名。
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 10:08
 */
public class ArrayExercise6 {
    public static void main(String[] args) {
        // 从键盘输入本组学员人数
        Scanner input = new Scanner(System.in);
        System.out.print("请输入学员的人数:");
        int num = input.nextInt();
        // 声明两个数组,一个存储本组学员的姓名,一个存储本组学员的成绩。
        String[] names = new String[num];
        double[] scores = new double[num];
        // 从键盘输入每一个人的姓名和成绩,分别存到两个数组中。
        for (int i = 0; i < num; i++) {
            System.out.print("请输入第" + (i + 1) + "个学员的姓名:");
            String name = input.next();
            names[i] = name;
            System.out.print("请输入第" + (i + 1) + "个学员的成绩:");
            double score = input.nextDouble();
            scores[i] = score;
        }
        // 找出最高分和最低分的学员的姓名
        double maxScore = scores[0];
        int maxScoreIndex = 0;
        double minScore = scores[0];
        int minScoreIndex = 0;
        for (int i = 0; i < scores.length; i++) {
            double score = scores[i];
            if (score >= maxScore) {
                maxScore = score;
                maxScoreIndex = i;
            }
            if (score <= minScore) {
                minScore = score;
                minScoreIndex = i;
            }
        }
        System.out.println("最高分是:" + maxScore);
        System.out.println("最高分的学员的名称是:" + names[maxScoreIndex]);
        System.out.println("最低分是:" + minScore);
        System.out.println("最低分的学员的名称是:" + names[minScoreIndex]);
    }
}

8.7 练习7

  • 有如下代码,请画出 i 等于3时的内存图:
int[] arr2 = new int[5];
for(int i=0; i<arr2.length; i++){
	arr[i] = i+1;
}

img

9 二维数组

9.1 概述

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

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

int[][] arr; // arr是一个二维数组,可以看成是int[]一维数组的一个数组
  • 二维数组也可以看成是一个二维表,行和列组成的二维表,只不过这个二维表中的每一行的列数可能不同。但是每一个单元格中的元素的数据类型是一致的,例如,都是int、String等类型。

img

9.2 二维数组的语法

9.2.1 动态初始化1

  • 语法:
数据类型[][] 数组名 = new 数据类型[m][n]
  • 解释:

    • m表示这个二维数组有多少个一维数组。换言之,一共多少行。
    • n表示每个一维数组中的元素有多少个,换言之,一共有多少个单元格。
    • 二维数组的访问和赋值方式和一维数组类似。
// 二维数组中元素的访问
数据类型 元素名 = 二维数组名[行下标][列下标];
// 二维数组中元素的赋值
 二维数组名[行下标][列下标] = 值;
  • 内存图:

img

  • 示例:
/**
 * 二维数组的动态初始化
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 13:08
 */
public class ArrayTest6 {
    public static void main(String[] args) {
        // 定义了一个名称为arr的二维数组
        // arr中有3个一维数组,每个一维数组中有2个元素。每个一维数组的名称是:arr[0]、arr[1]、arr[2]、
        int[][] arr = new int[3][2];

        // 二维数组元素的访问
        System.out.println("二维数组的元素的访问 = " + arr[0][0]);
        System.out.println("二维数组的元素的访问 = " + arr[0][1]);
        System.out.println("二维数组的元素的访问 = " + arr[1][0]);
        System.out.println("二维数组的元素的访问 = " + arr[1][1]);
        System.out.println("二维数组的元素的访问 = " + arr[2][0]);
        System.out.println("二维数组的元素的访问 = " + arr[2][1]);

        // 二维数组中的元素赋值
        arr[0][0] = 1;
        arr[0][1] = 2;
        arr[1][0] = 3;
        arr[1][1] = 4;
        arr[2][0] = 5;
        arr[2][1] = 6;

        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[0][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[0][1]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[1][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[1][1]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[2][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[2][1]);

    }
}

9.2.2 动态初始化2

  • 语法:
数据类型[][] 数组名 = new 数据类型[m][];
数组名[行下标] = new 数据类型[n];
  • 解释:

    • m表示这个二维数组有多少个一维数组,每个一维数组的元素的默认初始化值是null。
    • n表示给对一维数组进行初始化。
  • 内存示意图:

img

  • 示例:
/**
 * 二维数组的动态初始化
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 13:08
 */
public class ArrayTest7 {
    public static void main(String[] args) {
        // 动态创建一个二维数组
        int[][] arr = new int[3][];
        arr[0] = new int[1];
        arr[1] = new int[2];
        arr[2] = new int[3];

        // 二维数组的元素的访问
        System.out.println("二维数组的元素的访问 = " + arr[0][0]);
        System.out.println("二维数组的元素的访问 = " + arr[1][0]);
        System.out.println("二维数组的元素的访问 = " + arr[1][1]);
        System.out.println("二维数组的元素的访问 = " + arr[2][0]);
        System.out.println("二维数组的元素的访问 = " + arr[2][1]);
        System.out.println("二维数组的元素的访问 = " + arr[2][2]);

        // 二维数组中元素的赋值
        arr[0][0] = 1;
        arr[1][0] = 2;
        arr[1][1] = 3;
        arr[2][0] = 4;
        arr[2][1] = 5;
        arr[2][2] = 6;

        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[0][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[1][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[1][1]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[2][0]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[2][1]);
        System.out.println("赋值之后的二维数组的元素的访问 = " + arr[2][2]);
    }
}

9.2.3 静态初始化

  • 语法:
数据类型[][] 数组名 = new int[][]{{元素1,元素2,...},{元素1,元素2,...},{元素1,元素2,...},...}
数据类型[][] 数组名 = {{元素1,元素2,...},{元素1,元素2,...},{元素1,元素2,...},...}
数据类型[][] 数组名 ;
数组名 = new int[][]{{元素1,元素2,...},{元素1,元素2,...},{元素1,元素2,...},...}
  • 示例:
/**
 * 二维数组的静态初始化
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 14:08
 */
public class ArrayTest8 {
    public static void main(String[] args) {
        // 二维数组的静态初始化
        int[][] arr = new int[][]{{1,2}, {2, 3}, {4, 5, 6}};
        // 二维数组元素的访问
        System.out.println("二维数组的元素的访问 = " + arr[0][0]);
        System.out.println("二维数组的元素的访问 = " + arr[0][1]);
        System.out.println("二维数组的元素的访问 = " + arr[1][0]);
        System.out.println("二维数组的元素的访问 = " + arr[1][1]);
        System.out.println("二维数组的元素的访问 = " + arr[2][0]);
        System.out.println("二维数组的元素的访问 = " + arr[2][1]);
        System.out.println("二维数组的元素的访问 = " + arr[2][2]);
    }
}

9.3 二维数组的名称以及表达方式

  • 二维数组的长度/行数:
二维数组名.length
  • 二维数组的某一行:
// 行下标的范围是[0,二维数组名.length-1]
二维数组名[行下标]
  • 二维数组的某一行的列数:
// 二维数组的每一行是一个一维数组
二维数组名[行下标].length
  • 二维数组的某一个元素:
二维数组名[行下标][列下标]

9.4 二维数组的遍历

  • 语法:
for(int i=0; i<二维数组名.length; i++){
    for(int j=0; j<二维数组名[i].length; j++){
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}
  • 示例:
/**
 * 二维数组的遍历
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 14:08
 */
public class ArrayTest9 {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2}, {2, 3}, {4, 5, 6}};
        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();
        }
    }
}

10 Arrays工具的使用

10.1 概述

  • java.util.Arrays类即为操作数组的工具类,包含了用来操作数据的各种方法。

  • 判断两个数组是否相等:

// 重载方法
public static boolean equals(long[] a, long[] a2)
  • 输出数组信息:
// 重载方法
public static String toString(long[] a)
  • 将指定的数值填充到数组中:
// 重载方法
public static void fill(long[] a, long val)
  • 对数组进行排序:
// 重载方法
public static void sort(int[] a)
  • 对排序后的数组使用二分查找法查找指定的元素:
// 重载方法
public static int binarySearch(long[] a, long key)

10.2 应用示例

  • 示例:
import java.util.Arrays;

/**
 * Arrays工具类的使用
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 16:08
 */
public class ArraysTest {
    public static void main(String[] args) {
        int[] arr = {1, 5, 7, 3, 4, 1, 50, 8, 0, 4, -10, 100};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = {1, 5, 7, 3, 4, 1, 50, 8, 0, 4, -10, 100};

        System.out.println("判断两个数组是否相等(判断两个数组中的元素) = " + Arrays.equals(arr, arr2)); // false
        System.out.println("判断两个数组是否相等(判断两个数组中的元素) = " + Arrays.equals(arr, arr3)); // true

        System.out.println("输出数组信息 = " + Arrays.toString(arr)); // [1, 5, 7, 3, 4, 1, 50, 8, 0, 4, -10, 100]

        // 将指定的值填充的数组中
        Arrays.fill(arr2, 4);

        System.out.println("将指定的值填充的数组中 = " + Arrays.toString(arr2)); // [4, 4, 4]

        arr2 = new int[]{1, 2, 3};

        Arrays.fill(arr2, 1,2,-1); // [1, -1, 3]

        System.out.println("将指定的值填充的数组中 = " + Arrays.toString(arr2));

        // 对数组进行排序
        Arrays.sort(arr);
        System.out.println("将指定的值填充的数组中 = " + Arrays.toString(arr)); // [-10, 0, 1, 1, 3, 4, 4, 5, 7, 8, 50, 100]

        // 对排序后的数组使用二分查找法查找指定的元素,如果能找到,返回指定元素在数组中的索引,否则,返回-1
        System.out.println("Arrays.binarySearch(arr, 4) = " + Arrays.binarySearch(arr, 4)); // 5
    }
}

11 数组使用中的常见异常

11.1 ArrayIndexOfBoundsException

  • 数组索引越界异常:就是访问了数组中不存在的索引时发生的异常。

  • 示例:

/**
 * ArrayIndexOutOfBoundsException:数组索引越界异常
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 16:08
 */
public class ArrayTest10 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};

        System.out.println(arr[3]); // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
    }
}

11.2 NullPointerException

  • 空指针异常:数组没有指向堆内存的空间,我们却试图去访问堆内存空间中的值。

  • 示例:

/**
 * NullPointerException:空指针异常
 *
 * @author open1024
 * @version 1.0
 * @since 2021-08-13 16:08
 */
public class ArrayTest11 {
    public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr[0]); // Exception in thread "main" java.lang.NullPointerException
    }
}
0

评论区