4、Java基础---操作数组的方法
操作数组的方法
一、计算最大值的方法
计算最高者的身高和最胖者的体重：
import java.util.Scanner;
class MaxOfHeightWeight {
//--- 计算并返回数组a中的最大值 ---//
static int maxOf(int[] a) {
int max = a[0];
for (int i = 1; i < a.length; i++)
if (a[i] > max)
max = a[i];
return max;
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in);
System.out.print("人数：");
int ninzu = stdIn.nextInt(); // 读入人数
int[] height = new int[ninzu]; // 创建保存身高的数组
int[] weight = new int[ninzu]; // 创建保存体重的数组
System.out.println("请输入" + ninzu + "人的身高和体重。");
for (int i = 0; i < ninzu; i++) {
System.out.print((i + 1) + "号的身高：");
height[i] = stdIn.nextInt();
System.out.print((i + 1) + "号的体重：");
weight[i] = stdIn.nextInt();
}
System.out.println("最高者的身高：" + maxOf(height) + "cm");
System.out.println("最胖者的体重：" + maxOf(weight) + "kg");
}
}
输出：
main方法中首先读入人数，然后分别创建用于保存身高的数组height和用于保存体重的数组weight,并读入各个元素的值。
最后，调用方法maxOf,分别计算它们中的最大值；
方法maxOf会计算并返回数组元素中的最大值。用于接收数组的形参声明为int[] a, 这与数组变量的声明形式相同。
执行的数组传递情形如图所示：
由于实参height是引用数组主体的数组变量，因此传递给方法maxOf的是数组主体的引用；
在调用的方法maxOf中，形参a为数组变量，使用接收到的引用进行初始化。最终，数组变量a会引用数组height的主体；
换而言之，方法maxOf中的数组a实际上变为了main方法中的数组height。
二、线性查找
import java.util.Scanner;
class LinearSearch {
//--- 线性查找数组a的全部元素中最先与key值相同的元素 ---//
static int linearSearch(int[] a, int key) {
for (int i = 0; i < a.length; i++)
if (a[i] == key)
return i; // 查找成功（返回索引）
return -1; // 查找失败（返回-1）
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in);
System.out.print("元素个数：");
int num = stdIn.nextInt();
int[] x = new int[num]; // 元素个数为num的数组
for (int i = 0; i < num; i++) {
System.out.print("x[" + i + "]：");
x[i] = stdIn.nextInt();
}
System.out.print("要查找的值："); // 读入键值
int ky = stdIn.nextInt();
int idx = linearSearch(x, ky); // 查找数组x中值为ky的元素
if (idx == -1)
System.out.println("不存在该值的元素。");
else
System.out.println("该值的元素是" + "x[" + idx + "]。");
}
}
输出：
linearSearch用于执行线性查找，查找数组a的全部元素中最先与key值相同的元索；
当查找成功时，返回查找到的元素的索引，查找失败时，返回-1；
查找失败时返回的-1是一个不可能为数组索引的值。因此，查找成功和查找失败时返回的数值一定要能区别开
三、对数组中的元素进行倒序排列
将值读入到数组元素中，并进行倒序排列：
import java.util.Scanner;
class ReverseArray {
//--- 交换数组中的元素a[idx1]和a[idx2] ---//
static void swap(int[] a, int idx1, int idx2) {
int t = a[idx1]; a[idx1] = a[idx2]; a[idx2] = t;
}
//--- 对数组a中的元素进行倒序排列 ---//
static void reverse(int[] a) {
for (int i = 0; i < a.length / 2; i++)
swap(a, i, a.length - i - 1);
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in);
System.out.print("元素个数：");
int num = stdIn.nextInt(); // 元素个数
int[] x = new int[num]; // 元素个数为num的数组
for (int i = 0; i < num; i++) {
System.out.print("x[" + i + "] : ");
x[i] = stdIn.nextInt();
}
reverse(x); // 对数组x中的元素进行倒序排列
System.out.println("元素的倒序排列执行完毕。");
for (int i = 0; i < num; i++)
System.out.println("x[" + i + "] = " + x[i]);
}
}
输出：
方法reverse用来重新排列顺序，为了对数组中的元素进行倒序排列， 交换两个元素值的操作，需要执行（元素个数/ 2)次；
方法swap用来交换数组中的两个元素，该方法的形参接收数组（的引用） a及两个索引idxl和idx2；
该方法会交换a[idxl]和a[idx2]的值，例如调用swap(a, 1, 3)后，会交换a[1]和a[3]的值。
main方法中创建的数组的引用x被传递给了reverse, 而reverse中将形参a接收到的引用直接传递给了swap；
因此，方法reverse的形参a和swap的形参a都会引用main方法中创建的数组主体x。
四、比较两个数组
方法equals中会判断两个数组a和b中的全部元素是否相等，并根据判断结果返回true或false
判断两个数组是否相等：
import java.util.Scanner;
class ArrayEqual {
//--- 两个数组a, b中的全部元素是否相等？ ---//
static boolean equals(int[] a, int[] b) {
if (a.length != b.length)
return false;
for (int i = 0; i < a.length; i++)
if (a[i] != b[i])
return false;
return true;
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in);
System.out.print("数组a的元素个数：");
int na = stdIn.nextInt(); // 数组a的元素个数
int[] a = new int[na]; // 元素个数为na的数组
for (int i = 0; i < na; i++) {
System.out.print("a[" + i + "] : ");
a[i] = stdIn.nextInt();
}
System.out.print("数组b的元素个数：");
int nb = stdIn.nextInt(); // 数组b的元素个数
int[] b = new int[nb]; // 元素个数为nb的数组
for (int i = 0; i < nb; i++) {
System.out.print("b[" + i + "] : ");
b[i] = stdIn.nextInt();
}
System.out.println("数组a和b" +
(equals(a, b) ? "相等。"
: "不相等。"));
}
}
输出：
1）比较两个数组a、b的元素个数(长度);如果元素个数不同，则数组肯定不相等、返回 false；
if (a.length != b.length)
return false;2）代码使用for语句从头开始遍历两个数组，循环比较元素a[i]和b[i]的值，在比较过程中，如果发现元素的值不相等，则执行return语句，返回false
for (int i = 0; i < a.length; i++)
if (a[i] != b[i])
return false;3）当程序流程执行到此处时，并不是for语旬执行中断了，而是for语句全部执行结束了， 此时可以判断两个数组是相等的，因此返同true
return true;比较数组流程图：
五、返回数组的方法
创建一个全部元素的值与索引相同的数组：
import java.util.Scanner;
class GenIdxArray {
//--- 创建并返回一个全部元素的值与索引相同、元素个数为n的数组 ---//
static int[] idxArray(int n) {
int[] a = new int[n]; // 元素个数为n的数组
for (int i = 0; i < n; i++)
a[i] = i;
return a;
}
public static void main(String[] args) {
Scanner stdIn = new Scanner(System.in);
System.out.print("元素个数：");
int n = stdIn.nextInt(); // 元素个数
int[] x = idxArray(n); // 元素个数为n的数组
for (int i = 0; i < n; i++)
System.out.println("x[" + i + "] = " + x[i]);
}
}
输出：
方法idxArray的形参n会接收int型整数值，方法体中执行如下操作:
• 创建元素个数为n的数组a
• 数组a的全部元素中赋入与索引相同的值
• 返回a, 即数组主体的引用
六、多维数组的传递
计算两个矩阵的和：
class AddMatrix {
//--- 把x和y的和赋给z ---//
static void addMatrix(int[][] x, int[][] y, int[][] z) {
for (int i = 0; i < x.length; i++)
for (int j = 0; j < x[i].length; j++)
z[i][j] = x[i][j] + y[i][j];
}
//--- 显示矩阵m中的全部元素 ---//
static void printMatrix(int[][] m) {
for (int i = 0; i < m.length; i++) {
for (int j = 0; j < m[i].length; j++)
System.out.print(m[i][j] + " ");
System.out.println();
}
}
public static void main(String[] args) {
int[][] a = { {1, 2, 3}, {4, 5, 6} };
int[][] b = { {6, 3, 4}, {5, 1, 2} };
int[][] c = new int[2][3];
addMatrix(a, b, c); // 将a和b的和赋给c
System.out.println("矩阵a"); printMatrix(a);
System.out.println("矩阵b"); printMatrix(b);
System.out.println("矩阵c"); printMatrix(c);
}
}
输出：
方法addMatrix 中会计算矩阵x和矩阵y的和，并将计算结果保存到矩阵z中；
接收二维数组的形参声明与一般的二维数组的声明相同；
形参除了声明为int[] [] X之外，还可以声明为int x [] []或int[] x[];
另外一个方法printMatrix 中会显示接收到的二维数组m中的全部元素;以该方法为例，我们来理照一下二维数组的传递。
调用printMaxtix (a) 时，参数的传递情形如图所示:
传递端的实参a 是引用数组主体的数组变量；因此，与一维数组的情形相同，传递的并不是数组主体， 而是数组的引用。
调用的方法printMatrix 将数组的引用传递给形参m, 这样，方法printMatrix中就可以通过数组变量m访问创建的数组a的主体。