-
39-Java方法的参数传递的小案例
一、案例：打印整型数组内容
-
需求：
-
设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：
“该数组内容为：[11, 22, 33, 44, 55]”
-
-
分析：
- 首先，可以确定：定义一个有参数、无返回值的方法；
- 然后，使用循环遍历传入的数组，并按照需求给的格式来输出每一次遍历到的数组元素；
- 最后，在主方法里静态初始化一个数组，或者多个数组，直接录入元素，调用输出数组的方法，将静态初始化数组传递给方法中的形参。
-
实现：
-
定义输出数组方法: 返回值类型为void，形参为int类型的arrs数组
-
在数组方法内:
(2-1) 在循环开始前，打印一个不换行的输出格式作为开头: "该数组内容为: [ "
(2-2) 定义for循环对传入的数组进行遍历
(2-3) 取出数组元素：
(2-3-1) 使用if判断:
当取出的元素索引 等于 数组长度-1 时，表示该元素是数组中最后一个元素，则输出时不需要加 ", " 隔开；
否则，表示该元素不是数组中最后一个元素，则输出时需要加 ", " 隔开
(2-4) 在循环结束后，打印一个不换行的输出格式作为结尾: “]”
-
在main——主方法内：
(3-1) 静态初始化一个数组，直接录入元素数据: 11, 22, 33, 44, 55
(3-2) 调用输出数组的方法，将静态初始化数组——>传递给输出数组的方法的形参arrs
-
package com.app.param; /** 目标：通过案例：打印整型数组，更深入的理解引用类型的值传递机制 一、案例：打印整型数组内容 - 需求： - 设计一个方法用于输出任意整型数组的内容，要求输出成如下格式： "该数组内容为：[11, 22, 33, 44, 55]" - 分析： - 首先，可以确定：定义一个有参数、无返回值的方法； - 然后，使用循环遍历传入的数组，并按照需求给的格式来输出每一次遍历到的数组元素。 */ public class Test3 { // 1. 定义输出数组方法: 返回值类型为void，形参为数组类型的arrs public static void outputArray(int[] arrs) { // 2. 在数组方法内: // (2-1) 在循环开始前，打印一个不换行的输出格式作为开头: "该数组内容为: [" System.out.print("["); // (2-2) 定义for循环对传入的数组进行遍历 for (int i = 0; i < arrs.length; i++) { // (2-3) 取出数组元素: // (2-3-1) 使用if判断: if (i == arrs.length - 1) { // 当取出的元素索引 等于 数组长度-1 时，表示该元素是数组中最后一个元素， // 则输出时不需要加 ", " 隔开 System.out.print(arrs[i]); } else { // 否则，表示该元素不是数组中最后一个元素， // 则输出时需要加 ", " 隔开 System.out.print(arrs[i] + ", "); } } // (2-4) 在循环结束后，打印一个不换行的输出格式作为结尾: "]" System.out.print("]"); } // main——主方法 public static void main(String[] args) { // 3. 在main——主方法内： // (3-1) 静态初始化一个数组，直接录入元素数据: 11, 22, 33, 44, 55 int[] arrs = {11, 22, 33, 44, 55}; // (3-2) 调用数组方法，并将静态初始化数组——>传递给数组方法的形参arrs outputArray(arrs); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
输出结果： [11, 22, 33, 44, 55]- 1
- 2
- 3
优化打印整型数组方法
-
为了显得更专业、更严谨，进行一下优化：
-
在循环遍历前，先判断: 当数组等于null 且 数组长度>0 时，则可以遍历，否则表示数组为空
-
在 (2-3-1) 的地方可以使用三元运算符对代码进行优化:
-
格式:
条件表达式 ? 值1 : 值2- 1
package com.app.param; public class Test3 { // 1. 定义输出数组方法: 返回值类型为void，形参为数组类型的arrs public static void outputArray(int[] arrs) { // 2. 在输出数组方法内: // (2-1) 在循环开始前，打印一个不换行的输出格式作为开头: "[" System.out.print("["); // (2-2) 在循环遍历前，先判断: 当数组等于null 且 数组长度>0 时，则可以遍历，否则表示数组为空 if (arrs != null && arrs.length > 0) { // (2-3) 定义for循环对传入的数组进行遍历 for (int i = 0; i < arrs.length; i++) { // (2-4) 取出数组元素: // (2-4-1) 方式2——使用if判断: /*if (i == arrs.length - 1) { // 当取出的元素索引 等于 数组长度-1 时，表示该元素是数组中最后一个元素， // 则输出时不需要加 ", " 隔开 System.out.print(arrs[i]); } else { // 否则，表示该元素不是数组中最后一个元素， // 则输出时需要加 ", " 隔开 System.out.print(arrs[i] + ", "); }*/ // (2-4-1) 方式1——使用三元运算符判断: // 条件表达式 ? 值1(true) : 值2(false) // 当取出的元素索引 等于 数组长度-1 时 ? 则输出时不需要加 ", " 隔开 : 否则输出时需要加 ", " 隔开 System.out.print( i == arrs.length - 1 ? arrs[i] : arrs[i] + ", " ); } } // (2-5) 在循环结束后，打印一个不换行的输出格式作为结尾: "]" System.out.print("]"); } // main——主方法 public static void main(String[] args) { // 3. 在main——主方法内： // (3-1) 静态初始化一个数组，直接录入元素数据: 11, 22, 33, 44, 55 int[] arrs = {11, 22, 33, 44, 55}; // (3-2) 调用输出数组方法，并将静态初始化数组——>传递给数组方法的形参arrs outputArray(arrs); System.out.println("\n--------------------------------------"); // 再静态初始化一个数组，用于测试 int[] ages = {22, 20, 18, 19, 16, 60, 34}; outputArray(ages); System.out.println("\n--------------------------------------"); // 静态初始化一个空数组 和 一个数组长度 < 0的数组 int[] nullArr = null; int[] numbers = {}; outputArray(nullArr); System.out.println("\n--------------------------------------"); outputArray(numbers); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
输出结果： [11, 22, 33, 44, 55] -------------------------------------- [22, 20, 18, 19, 16, 60, 34] -------------------------------------- [] -------------------------------------- []- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
-
-
重点： 永远记住，传递的是数组内存地址，遍历是通过地址去访问地址对象，取出元素，而不是直接遍历出元素
二、案例：从数组中查询指定元素的索引
-
需求：
- 设计一个方法可以接收整型数组，和要查询的元素值；最终要返回元素在数组中的索引，如果数组中不存在该元素则返回 -1。
- 例如：[11, 22, 33, 44, 55]
- 输入元素: 44。返回索引: 3
- 输入元素: 88。返回索引: -1
-
分析：
-
首先，由于需要接收整型数组，和要查询的元素值，最终还要返回元素在数组中的索引，因此需要设计一个有参数、有返回值的查询索引的方法；
-
然后，使用for循环对传入的数组进行遍历；接着判断: 接收到的元素参数 是否 存在数组中，存在则返回该元素的索引；
当循环结束了，仍然找不到要查询的元素，说明不存在则返回-1；
-
最后，在主方法内，静态初始化几个数组，录入元素后——>调用检查数组的方法，并将静态初始化数组传递给方法中的形参
-
实现：
-
定义查询索引的方法: searchIndex，返回值类型: int，形参1: int类型的数组—>arrs，形参2: int类型的—>arrayData；
-
使用for循环对传入的数组进行遍历:
(2-1) 使用if判断：
接收到的元素参数 是否 存在数组中，存在则返回该元素的索引
-
当循环结束了，仍然找不到要查询的元素，说明不存在则返回-1；
-
在main——主方法内：
(3-1) 静态初始化一个年龄数组，录入年龄；调用查询索引的方法，将年龄数组传递给方法中的形参1: arrs，将你要查询的数据——>传递给形参2: arrayData，用变量接收一下调用的结果，最后输出索引
(3-3) 静态初始化一个颜值数组，录入颜值；调用查询索引的方法，将颜值数组传递给方法中的形参1: arrs，将一个数组中不存在的数据——>传递给形参2: arrayData，用变量接收一下调用的结果，最后输出索引
-
package com.app.param; /** - 需求： - 设计一个方法可以接收整型数组，和要查询的元素值；最终要返回元素在数组中的索引，如果数组中不存在该元素则返回 -1。 - 例如: [11, 22, 33, 44, 55] 索引: 0 1 2 3 4 - 输入元素: 44。返回索引: 3 - 输入元素: 88。返回索引: -1 - 分析: - 首先，由于需要接收整型数组，和要查询的元素值，最终还要返回元素在数组中的索引，因此需要设计一个有参数、有返回值的查询索引的方法； - 然后，使用for循环对传入的数组进行遍历；接着判断: 接收到的元素参数 是否 存在数组中，存在则返回该元素的索引； 当循环结束了，仍然找不到要查询的元素，说明不存在则返回-1； - 最后，在主方法内，静态初始化几个数组，录入元素后——>调用检查数组的方法， 并将静态初始化数组传递给方法中的形参1: 数组，将要查询的数据传递给形参2: 数组数据 */ public class Test4 { // 1. 定义查询索引的方法: searchIndex，返回值类型: int，形参1: int类型的数组—>arrs，形参2: int类型的—>arrayData public static int searchIndex(int[] arrs, int arrayData) { // 2. 使用for循环对传入的数组进行遍历: for (int i = 0; i < arrs.length; i++) { // (2-1) 使用if判断： if (arrayData == arrs[i]) { // 接收到的数组元素是否存在数组中， //存在，则返回该元素在数组中的索引 return i; } } // 3.当循环结束了，仍然找不到要查询的元素，说明不存在则返回-1 return -1; } // main主方法 public static void main(String[] args) { // 3. 在main——主方法内： // (3-1) 静态初始化一个年龄数组，录入年龄；调用查询索引的方法，最后输出索引 int[] ages = {19, 20, 23, 25, 38}; // 将年龄数组传递给方法中的形参1: arrs，将你要查询的数据——>传递给形参2: arrayData，用变量接收一下调用的结果， int index = searchIndex(ages, 20); // 最后输出索引 System.out.println("您查询的数据的索引是: " + index); System.out.println("------------------------------------"); // (3-3) 静态初始化一个颜值数组，录入颜值；调用查询索引的方法， int[] faceValue = {1000, 30000, 4000, -5}; // 将颜值数组传递给方法中的形参1: arrs，将一个数组中不存在的数据——>传递给形参2: arrayData，用变量接收一下调用的结果， int index2 = searchIndex(faceValue, 2000); // 最后输出索引 System.out.println("您查询的数据的索引是: " + index2); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
输出结果： 您查询的数据的索引是: 1 ------------------------------------ 您查询的数据的索引是: -1- 1
- 2
- 3
- 4
- 5
- 6
- 重点： 有返回值的方法，在调用时，要么直接输出，要么就用变量接收一下，如果你只是调用，不接收，也不输出，那是不会有输出结果的
三、案例：比较两个数组的内容是否一样
-
需求：
- 如果两个数组的类型，元素个数，元素顺序和内容是一样的我们就认为这两个数组是一模一样的。
- 例如：
- int[] arrs = {10, 20, 30};
- int[] arrs2 = {10, 20, 30};
- 请使用方法完成：能够判断任意两个整型数组是否一样，并返回true或者false。
-
分析：
-
首先，由于要进行数组对比，并且需要返回true或者false，因此需要设计一个有参数、有返回值的数组比较的方法
-
然后，在方法内，使用if判断:
当数组1的元素个数 等于 数组2的元素个数 时，则判断为true，代表两个数组元素个数相同，
使用for循环：
两个数组只需要遍历一个数组，使用if判断：当数组1的元素顺序 不等于 数组2的元素顺序 时，代表两个数组元素顺序 不一 样，返回false；当循环结束了，代表两个数组的每一个元素的顺序是一样的，返回true。
否则代表两个数组元素个数不同，返回false；
-
最后，在主方法内，静态初始化两个一样的数组和两个不一样的数组，分别录入一样的元素和录入不一样的元素
调用数组比较的方法，将两个一样的数组传递给方法中的形参1: 数组1, 形参2: 数组2，并用变量接收调用结果，输出比较结果；
调用数组比较的方法，将两个不一样的数组传递个方法中的形参1: 数组1, 形参2: 数组2，并用变量接收调用结果，输出比较结果。
-
-
实现：
-
定义数组比较的方法: compareArray，返回值类型: boolean，形参1: arrs1, 形参2: arrs2
-
在数组比较的方法内：
(2.1) 使用if判断:
(2.1.1) 当arrs1的元素个数 等于 arrs2的元素个数 时，判断为true，则代表两个数组个数相同，
(2.1.1.1) 使用for循环对其中一个传入的数组进行遍历：
(2.1.1.1.1)使用if判断：
当arrs1的每一个元素的顺序 不等于 arrs2的每一个元素的顺序 时，判断为false，则代表两个数组的每一个元 素的顺序不一样，返回false；
(2.1.1.2) 当循环结束了，代表两个数组的每一个元素的顺序是一样的，返回true。
(2.1.2) 否则代表两个数组的元素个数不同，返回false。
-
在main——主方法内：
(3.1) 静态初始化两个一样的数组: ages1, ages2；分别录入一样的元素;
(3.2) 调用数组比较的方法，将两个一样的数组传递给方法中的形参1: arrs1, 形参2: arrs2，并用变量接收调用结果;
(3.3) 输出两个一样的数组的比较结果。
(3.4) 静态初始化两个不一样的数组: faceValue1, faceValue2；分别录入不一样的元素或者两个数组的元素顺序弄乱；
(3.5) 调用数组比较的方法，将两个不一样的数组传递给方法中的形参1: arrs1, 形参2: arrs2，并用变量接收调用结果；
(3.6) 输出两个不一样的数组的比较结果。
-
package com.app.param; /** 三、案例：比较两个数组的内容是否一样 - 需求： - 如果两个数组的类型，元素个数，元素顺序和内容是一样的我们就认为这两个数组是一模一样的。 - 例如： - int[] arrs = {10, 20, 30}; - int[] arrs2 = {10, 20, 30}; - 请使用方法完成：能够判断任意两个整型数组是否一样，并返回true或者false。 - 分析： - 首先，由于要进行数组对比，并且需要返回true或者false，因此需要设计一个有参数、有返回值的数组比较的方法 - 然后，在方法内，使用if判断: 当数组1的元素个数 等于 数组2的元素个数 时，则判断为true，代表两个数组元素个数相同， 使用for循环： 两个数组只需要遍历一个数组，使用if判断：当数组1的元素顺序 不等于 数组2的元素顺序 时，代表两个数组元素顺序 不一样，返回false； 当循环结束了，代表两个数组的每一个元素的顺序是一样的，返回true。 否则代表两个数组元素个数不同，返回false； - 最后，在主方法内，静态初始化两个一样的数组和两个不一样的数组，分别录入一样的元素和录入不一样的元素 调用数组比较的方法，将两个一样的数组传递给方法中的形参1: 数组1, 形参2: 数组2，并用变量接收调用结果，输出比较结果； 调用数组比较的方法，将两个不一样的数组传递个方法中的形参1: 数组1, 形参2: 数组2，并用变量接收调用结果，输出比较结果。 */ public class Test5 { // 1. 定义数组比较的方法: compareArray，返回值类型: boolean，形参1: arrs1, 形参2: arrs2 public static boolean compareArray(int[] arrs1, int[] arrs2) { // 2. 在数组比较的方法内： // (2.1) 使用if判断: if (arrs1.length == arrs2.length) { // (2.1.1) 当arrs1的元素个数 等于 arrs2的元素个数时，判断为true，则代表两个数组个数相同， // (2.1.1.1) 使用for循环对其中一个传入的数组进行遍历： for (int i = 0; i < arrs1.length; i++) { // (2.1.1.1.1)使用if判断： if (arrs1[i] != arrs2[i]) { // 当arrs1的每一个元素的顺序 不等于 arrs2的每一个元素的顺序 时， // 判断为false，则代表两个数组的每一个元素的顺序不一样，返回false； return false; } } // (2.1.1.2) 当循环结束了，代表两个数组的每一个元素的顺序是一样的，返回true。 return true; }else { // (2.1.2) 否则代表两个数组的元素个数不同， // 返回false。 return false; } } // main主方法 public static void main(String[] args) { // 3. 在main——主方法内： // (3.1) 静态初始化两个一样的数组: ages1, ages2；分别录入一样的元素 int[] ages1 = {19, 18, 20, 22, 34}; int[] ages2 = {19, 18, 20, 22, 34}; // (3.2) 调用数组比较的方法，将两个一样的数组传递给方法中的形参1: arrs1, 形参2: arrs2，并用变量接收调用结果 boolean compareResult1 = compareArray(ages1, ages2); // (3.3) 输出两个一样的数组的比较结果 System.out.println("ages1与ages2的比较结果是: " + compareResult1); System.out.println("------------------------------------------"); // (3.4) 静态初始化两个不一样的数组: faceValue1, faceValue2；分别录入不一样的元素或者两个数组的元素顺序弄乱 int[] faceValue1 = {1000, 2000, -5, 40000}; int[] faceValue2 = {1000, 2000, 40000, -5}; // int[] faceValue2 = {1000, 5000, 9000, 40000}; // (3.5) 调用数组比较的方法，将两个不一样的数组传递给方法中的形参1: arrs1, 形参2: arrs2，并用变量接收调用结果 boolean compareResult2 = compareArray(faceValue1, faceValue2); // (3.6) 输出两个不一样的数组的比较结果 System.out.println("faceValue1与faceValue2的比较结果是: " + compareResult2); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
输出结果： ages1与ages2的比较结果是: true ------------------------------------------ faceValue1与faceValue2的比较结果是: false- 1
- 2
- 3
- 4
- 5
- 6
- 重点： 返回类型是什么类型，接收的时候就用对应的类型接收
-
-
相关阅读:
知识表示学习（二）：TransH
Python常见操作的时间复杂度
二十、处理器调度（RR时间片轮转，MLFQ多级反馈队列，CFS完全公平调度器，优先级翻转；多处理器调度）
1.7-34:回文子串
软件测试面试会问哪些问题？
【vue3】toRef与toRefs的使用，toRef与ref的区别
14.IP协议-bite
Postman —— 配置环境变量
一键转换bmp到jpg，轻松优化你的图片管理
07-JS事件：事件类型、事件对象、事件传播、事件委托
- 原文地址：https://blog.csdn.net/yelitoudu/article/details/125600619
