目录
引语
小伙伴们大家好啊，之前我们说了数组与方法的简单定义，那今天我举两个例子，给大家更深刻的去了解我们的方法与数组，更好的去实际应用。
综合实战
题目一
请先看题目要求
冒泡排序，首先实现如下的数组从小到大排序，再完成下面的需求。
int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
(1).反转上面的数组。请代码实现
(2).复制上述数组，得到一个新的数组
(3).使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。
可以看到，题目有四个要求，这种情况我们首先可以想到用方法去实现他，因为这样可以让我们的代码更简洁，也可以让我们有更清晰的思路，不是一团乱
其次：题目无非就考了四种问题，冒泡，反转，复制数组到一个新的数组当中，查找返回索引，这种经典的问题。那么我们一个一个的说。
第一个，冒泡排序
要实现冒泡，就要先了解冒泡，冒泡是什么呢？
冒泡的原理：比较相邻的元素，如果一个元素比后一个元素大，就交换这两个元素的位置； 对每一对相邻元素做同样的工作，从第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
要实现数组中挨个比对，就不免用到循环，那么这里我就直接上代码public static void buddleSort(int[] arr) {
int temp;
for (int i = arr.length - 1; i > 0; i--) {//控制有多少个元素参与冒泡
for (int j = 0; j < i; j++) {//遍历数组
if (arr[j] > arr[j + 1]) {//如果索引i处的值大于索引i+1处的值
temp = arr[j];//就把索引j处的值赋值给temp
arr[j] = arr[j+ 1];//索引j+1处的 值赋值给索引j
arr[j+1] = temp;//最后将temp中存储的j的值赋值给j+1，完成交换
}
}
}
}第一个i表示的就是数组最后的索引值，每完成一次内循环，也就代表最大值已经冒泡到最后一个位置，所以i的值也应该相应的减少一位，即最后一位值变不再参与运算，依次类推。
if条件则表示数组中j值与j+1值依次比对，如果前一个数比后一个数大，那么久讲两数的位置交换，直到遇到比该数大的则停止。循环结束之后，冒泡排序则完成，那么这道题用代码可以写成如下
//返回值类型：void
//参数：int[] arr
public static void bubbleSort(int[] arr) {
int temp = 0;
//控制参与运算的元素递减，从最后一个下标递减
for (int i = arr.length - 1; i > 0; i--) {
//遍历
for (int j = 0; j < i; j++) {
//交换元素
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}第二个：反转
反转便是将数组的每一对元素反过来。
这个完全就是一个元素位置对调，所以把索引对调也就OK。
//返回值类型：void
//参数：int[] arr
public static void reserveSort(int[] arr) {
//定义一个临时变量
int temp = 0;
//参与运算的元素是一对一对的，所以只有一半
for (int i = 0; i < arr.length / 2; i++) {
temp = arr[i];
//将反转的元素对调
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
第三个：复制。
即我们需要定义一个新的数组，将原数组的值赋值给这个新数组。
//返回值类型：int[]
//参数： int[]arr
public static int[] copySort(int[] arr) {
//定义一个新数组brr
int[] brr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
//复制
brr[i] = arr[i];
}
return brr;第四个：查找
查找我们并不陌生，要想实现查找数组的元素，那就是索引，只要找到索引，那么问题也就迎刃而解。
//返回值类型：int 类型的数。
//参数：int类型的数组，int 类型的定义的查找的数。
public static int findSort(int[] arr, int num) {
//定义索引返回值
int index = 0;
//遍历数组
for (int i = 0; i < arr.length; i++) {
//如果要查找的数能在数组中找的，就返回其索引。
if (num == arr[i]) {
index = i;
return index;
}
}
//不存在，返回-1
return -1;
}按照题目的要求，我们还应该给该题目的返回做一个提示，那么可以有一下操作：
if (flag != -1) {//打印
System.out.println("找到了，下标为" + flag);
} else {
System.out.println("你找的数不存在数组");
}
}题目二
求一个3*3矩阵对角线元素之和，要求矩形里面的值为随机赋值
看题目我们不难看出，题目有三个要求1.创建一个二维数组，长度为3，其一维数组长度也为3
2.随机赋值
3.找出对角线规律，求和
都是些简单地问题，那么如何找到对角线规律呢？
我们将它带到索引当中去看，因为说到底他是数组，并且他的数值小，只有5个，即i = 0，j=0;i=0,j=2;i=1,j=1;i=2,j=2;i=2,j=0。
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = r.nextInt(100);
//矩形对应的\这个斜边的值
if (i == j) {
sum += arr[i][j];
//矩形剩余的两个值
} else if ((i == 0 && j == 2) || (i == 2 && j == 0)) {
sum +=arr[i][j];
}
}
}
找出这个规律之后输出就可以啦！
好了，以上就是我所分享的经典例题，希望对大家有所帮助，大家可以在评论区互相探讨哈，共同进步，那么最后再给大家一道经典例题，我就不解释了哦。
例题源码
package com.company;
/*
数组a："1,7,9,11,13,15,17,19"
数组b："2,4,6,8,10"
两个数组合并为数组c。
总思想：1.先将两个数组拼接起来
2.再用冒泡排序将其按顺序排列
3.打印输出
*/
public class Merge {
public static void main(String[] args) {
int[] arr1 = {1, 7, 9, 11, 13, 15, 17, 19};
int[] arr2 = {2, 4, 6, 8, 10};
//定义第三个数组为前两个数组的长度之和
int[] arr3 = new int[arr1.length + arr2.length];
getNewArr(arr1, arr2, arr3);
print(arr3);
}
public static void getNewArr(int[] arr1, int[] arr2, int[] arr3) {
//将第一个数组的值依次赋值给第三个数组
for (int i = 0; i < arr1.length; i++) {
arr3[i] = arr1[i];
}
//定义一个索引自第一个数组长度位置起
int thru = arr1.length;
for (int i = 0; i < arr2.length; i++) {
//将数组二的值赋值给它
arr3[thru] = arr2[i];
thru++;
}
//排序
for (int i = arr3.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (arr3[j] > arr3[j + 1]) {
int temp = arr3[j];
arr3[j] = arr3[j + 1];
arr3[j + 1] = temp;
}
}
}
}
public static void print(int[] arr3) {
System.out.print("[");
for (int i = 0; i < arr3.length; i++) {
if (i == arr3.length - 1) {
System.out.print(arr3[i]);
} else {
System.out.print(arr3[i] + ",");
}
}
System.out.print("]");
}
}
第一题源代码
package Homework;
import java.util.Scanner;
/*
7.冒泡排序，首先实现如下的数组从小到大排序，再完成下面的需求。
int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
(1).反转上面的数组。请代码实现
(2).复制上述数组，得到一个新的数组
(3).使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。
*/
public class Comprehensive {
public static void main(String[] args) {
//冒泡排序，首先实现如下的数组从小到大排序，再完成下面的需求。
int[] arr = new int[]{34, 5, 22, -98, 6, -76, 0, -3};
bubbleSort(arr);
printSort(arr);
// (1).反转上面的数组。请代码实现
reserveSort(arr);
printSort(arr);
// (2).复制上述数组，得到一个新的数组
int[] brr = copySort(arr);
printSort(brr);
//使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要查找的数：");
int num = sc.nextInt();
int flag = findSort(arr, num);
if (flag != -1) {//打印
System.out.println("找到了，下标为" + flag);
} else {
System.out.println("你找的数不存在数组");
}
}
//返回值类型：int 类型的数。
//参数：int类型的数组，int 类型的定义的查找的数。
public static int findSort(int[] arr, int num) {
//定义索引返回值
int index = 0;
//遍历数组
for (int i = 0; i < arr.length; i++) {
//如果要查找的数能在数组中找的，就返回其索引。
if (num == arr[i]) {
index = i;
return index;
}
}
//不存在，返回-1
return -1;
}
//返回值类型：int[]
//参数： int[]arr
public static int[] copySort(int[] arr) {
//定义一个新数组brr
int[] brr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
//复制
brr[i] = arr[i];
}
return brr;
}
//返回值类型：void
//参数：int[] arr
public static void reserveSort(int[] arr) {
//定义一个临时变量
int temp = 0;
//参与运算的元素是一对一对的，所以只有一半
for (int i = 0; i < arr.length / 2; i++) {
temp = arr[i];
//将反转的元素对调
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
//返回值类型：void
//参数：int[] arr
public static void bubbleSort(int[] arr) {
int temp = 0;
//控制参与运算的元素递减，从最后一个下标递减
for (int i = arr.length - 1; i > 0; i--) {
//遍历
for (int j = 0; j < i; j++) {
//交换元素
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//输出方法
public static void printSort(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ",");
}
}
System.out.println("]");
}
第二题源代码
package Homework;
//求一个3*3矩阵对角线元素之和，要求矩形里面的值为随机赋值
import java.util.Random;
public class Matrix {
public static void main(String[] args) {
//初始化
int[][] arr = new int[3][3];
Random r = new Random();
int sum = 0;
//二维数组的遍历赋值
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = r.nextInt(100);
//矩形对应的\这个斜边的值
if (i == j) {
sum += arr[i][j];
//矩形剩余的两个值
} else if ((i == 0 && j == 2) || (i == 2 && j == 0)) {
sum +=arr[i][j];
}
}
}//可以输出随机生成的数组，验证答案
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println( );
}
System.out.println("对角线和为：" + sum);
}
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
