1 容器概述

1.1 案例分析

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

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

1.2 容器概念

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

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

2 数组简介

2.1 数组的概念

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

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

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 数据类型[长度];

• 此时，只确定了数组的长度，那么数组中的元素是什么？

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

7 数组内存示意图

7.1 内存概述

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

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

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

7.2 Java虚拟机的内存划分

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

区域名称	作用
程序计数器	程序计数器是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
    }
}

• 问：打印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);
    }
}

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]);
    }
}

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;
}

9 二维数组

9.1 概述

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

• 二维数组的标记：[][]。

int[][] arr; // arr是一个二维数组，可以看成是int[]一维数组的一个数组

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

9.2 二维数组的语法

9.2.1 动态初始化1

• 语法：

数据类型[][] 数组名 = new 数据类型[m][n]

• 解释：

• • m表示这个二维数组有多少个一维数组。换言之，一共多少行。
• • n表示每个一维数组中的元素有多少个，换言之，一共有多少个单元格。
• • 二维数组的访问和赋值方式和一维数组类似。

// 二维数组中元素的访问
数据类型 元素名 = 二维数组名[行下标][列下标];
// 二维数组中元素的赋值
 二维数组名[行下标][列下标] = 值;

• 内存图：

• 示例：

/**
 * 二维数组的动态初始化
 *
 * @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表示给对一维数组进行初始化。

• 内存示意图：

• 示例：

/**
 * 二维数组的动态初始化
 *
 * @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
    }
}