一、案例：打印整型数组内容
-
需求：
-
设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：
“该数组内容为：[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);
}
}
输出结果：
[11, 22, 33, 44, 55]
优化打印整型数组方法
-
为了显得更专业、更严谨，进行一下优化：
-
在循环遍历前，先判断: 当数组等于null 且 数组长度>0 时，则可以遍历，否则表示数组为空
-
在 (2-3-1) 的地方可以使用三元运算符对代码进行优化:
-
格式:
条件表达式 ? 值1 : 值2
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); } }输出结果： [11, 22, 33, 44, 55] -------------------------------------- [22, 20, 18, 19, 16, 60, 34] -------------------------------------- [] -------------------------------------- [] -
-
重点： 永远记住，传递的是数组内存地址，遍历是通过地址去访问地址对象，取出元素，而不是直接遍历出元素
二、案例：从数组中查询指定元素的索引
-
需求：
- 设计一个方法可以接收整型数组，和要查询的元素值；最终要返回元素在数组中的索引，如果数组中不存在该元素则返回 -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
------------------------------------
您查询的数据的索引是: -1
- 重点： 有返回值的方法，在调用时，要么直接输出，要么就用变量接收一下，如果你只是调用，不接收，也不输出，那是不会有输出结果的
三、案例：比较两个数组的内容是否一样
-
需求：
- 如果两个数组的类型，元素个数，元素顺序和内容是一样的我们就认为这两个数组是一模一样的。
- 例如：
- 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);
}
}
输出结果：
ages1与ages2的比较结果是: true
------------------------------------------
faceValue1与faceValue2的比较结果是: false
- 重点： 返回类型是什么类型，接收的时候就用对应的类型接收
516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
