-
008-JavaSE基础巩固练习：数组综合练习
数组综合练习
一、遍历数组并求和
-
需求：
- 定义一个数组，存储1, 2, 3, 4, 5
- 遍历数组得到每一个元素，求数组里面所有的数据和。
-
实现：
package com.app.demo10_array_practice; /** 数组的练习 遍历数组并求和： 需求：定义一个数组，存储 1,2,3,4,5 遍历数组得到每一个元素，求数组里面所有的数据和 */ public class ArrayDemo1 { public static void main(String[] args) { // 1、定义一个数组，存储12345 int[] arr1 = {1, 2, 3, 4, 5}; int[] arr2 = null; int[] arr3 = {}; int[] arr4 = {2, 10, 3, 6}; // 2、调用数组元素求和的方法，传入一个数组，进行求和 int result1 = arrayElementsSum(arr1); System.out.println(result1); System.out.println(arrayElementsSum(arr2)); System.out.println(arrayElementsSum(arr3)); System.out.println(arrayElementsSum(arr4)); } /** * 3、数组元素求和的实现方法 * @param arr 接收一个数组 * @return 返回数组元素求和结果 */ private static int arrayElementsSum(int[] arr) { // 传入的数组不能为null if (arr == null) { return 0; } // 定义求和变量，用于累加每次遍历数组得到的元素值 int sum = 0; // 遍历数组元素 for (int i = 0; i < arr.length; i++) { // 每次得到数组的元素值，进行累加 sum += arr[i]; } // 循环结束！说明求和完成。返回结果 return sum; } }- 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
15 0 0 21 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
二、统计个数
-
需求：
- 定义一个数组，存储1, 2, 3, 4, 5, 6, 7, 8, 9, 10
- 遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
-
实现：
package com.app.demo10_array_practice; /** 数组的练习 统计个数： 需求：定义一个数组，存储1,2,3,4,5,6,7,8,9,10 遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字 */ public class ArrayDemo2 { public static void main(String[] args) { // 1、定义一个数组，存储1,2,3,4,5,6,7,8,9,10 int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int[] arr2 = null; // 2、调用统计数组的方法，传入数组 int count = countArray(arr1); System.out.println("arr1数组中能被3整除的数有：" + count + "个。"); System.out.println(countArray(arr2)); } /** * 3、统计数组里能被3整除的数字个数的实现方法 * @param arr 接收一个数组 * @return 返回能被3整除的数字统计结果 */ private static int countArray(int[] arr) { // 传入的数组不能为null if (arr == null) { return 0; } // 定义计数变量，用于记录能被3整除的数字个数 int count = 0; // 遍历数组，得到每个元素 for (int i = 0; i < arr.length; i++) { // 判断每次得到的数字是否能被3整除，否则继续循环判断 if (arr[i] % 3 == 0) { // 能，统计个数 count++; } } // 循环结束，说明统计完成，返回统计结果 return count; } }- 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
arr1数组中能被3整除的数有：3个。 0 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
三、变化数据
-
需求：
- 定义一个数组，存储1,2,3,4,5,6,7,8,9,10
- 遍历数组得到每一个元素。
- 如果是奇数，则将当前数字扩大两倍
- 如果是偶数，则将当前数字变成二分之一
-
实现：
package com.app.demo10_array_practice; /** 数组的练习 变化数据： 需求：定义一个数组，存储1,2,3,4,5,6,7,8,9,10 遍历数组得到每一个元素 如果是奇数，则将当前数字扩大两倍 如果是偶数，则将当前数字变成原来的二分之一 */ public class ArrayDemo3 { public static void main(String[] args) { // 1、定义一个数组，存储1,2,3,4,5,6,7,8,9,10 int[] arr = {1,2,3,4,5,6,7,8,9,10}; // 2、调用变化数据的方法，传入数组 changeData(arr); } /** * 3、变化数组数据的实现方法 * @param arr 接收一个数组 */ private static void changeData(int[] arr) { // 传入的数组不能为null if (arr == null) { System.out.println("参数不能为null"); return; } // 遍历数组，得到每一个元素 for (int i = 0; i < arr.length; i++) { // 每遍历到一个数，就判断是否为奇数，否则为偶数 if (arr[i] % 2 == 1) { // 是奇数，将该数扩大两倍 System.out.print("原" + arr[i] + "变成: " + (arr[i] * 2) + ", "); }else{ // 是偶数，将该数变成原来的二分之一 System.out.println( "原" + arr[i] + "变成: " + ( i == arr.length - 1 ? arr[i] / 2 : ((arr[i] / 2) + ", ") ) ); } } } }- 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
原1变成: 2, 原2变成: 1, 原3变成: 6, 原4变成: 2, 原5变成: 10, 原6变成: 3, 原7变成: 14, 原8变成: 4, 原9变成: 18, 原10变成: 5 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
四、求最值
1、最大值
-
需求：
- 已知数组元素为：{33, 5, 22, 44, 55}
- 请找出数组中最大值并打印在控制台
-
分析：
- 先将数组中的首元素拿出来
- 然后遍历数组中的每一个元素，从第二个元素开始与数组的首元素进行比较
- 如果第二元素比首元素大，那就替换掉首元素
- 比完后，最终的首元素就是最大值了
-
实现：
package com.app.demo10_array_practice; /** 数组的练习 求最值： 需求：已知数组元素为: 33,5,22,44,55 请找出数组中最大值并打印在控制台 */ public class ArrayDemo4 { public static void main(String[] args) { // 1、定义数组存储33,5,22,44,55 int[] arr1 = {33, 5, 22, 44, 55}; // 索引 0 1 2 3 4 // 2、调用求数组最大值的方法 int maxValue = arrayMaxElement(arr1); System.out.println("arr1数组中的最大值是：" + maxValue); int[] arr2 = {66, 2, 44, 99, 33, 44}; System.out.println("arr2数组中的最大值是：" + arrayMaxElement(arr2)); } /** * 3、求数组最大值的实现方法 * @param arr 接收一个数组 * @return 返回数组中的最大值 */ private static int arrayMaxElement(int[] arr) { // 传入的数组不能为null if (arr == null) { return 0; } // 取出数组中的首元素，用于与其他元素做比较，如果其他元素比这个元素大，就替换 int max = arr[0]; // 遍历数组，得到每一个元素 // i = 1: 直接从第二个元素开始比较，如果 i = 0: 还要自己和自己比，不符合逻辑 for (int i = 1; i < arr.length; i++) { // 判断当前元素 是否大于 首元素 if (arr[i] > max) { // 说明当前元素 大于 首元素，将当前元素 变成 首元素 max = arr[i]; } // 如果没进入if判断，说明当前元素 小于 首元素，则继续遍历，继续判断 } // 循环结束，说明已经比较完了！此时first里的值已经是数组中的最大值，返回最大值 return max; } }- 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
arr1数组中的最大值是：55 arr2数组中的最大值是：99 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
2、最小值
-
需求：
- 已知数组元素为：{66,2,44,99,33,44}
- 请找出数组中最小值并打印在控制台
-
实现：
package com.app.demo10_array_practice; /** 数组的练习 求最值： 1.求最大值 需求：已知数组元素为: 33,5,22,44,55 请找出数组中最大值并打印在控制台 2.求最小值 需求：已知数组元素为：66,2,44,99,33,44 请找出数组中最小值并打印在控制台 */ public class ArrayDemo4 { public static void main(String[] args) { // 1、定义数组存储33,5,22,44,55 int[] arr1 = {33, 5, 22, 44, 55}; // 索引 0 1 2 3 4 // 2、调用求数组最大值的方法 int maxValue = arrayMaxElement(arr1); System.out.println("arr1数组中的最大值是：" + maxValue); int[] arr2 = {66, 2, 44, 99, 33, 44}; System.out.println("arr2数组中的最小值是：" + arrayMinElement(arr2)); } /** * 3、求数组最大值的实现方法 * @param arr 接收一个数组 * @return 返回数组中的最大值 */ private static int arrayMaxElement(int[] arr) { // 传入的数组不能为null if (arr == null) { return 0; } // 取出数组中的首元素，用于与其他元素做比较，如果其他元素比这个元素大，就替换 int max = arr[0]; // 遍历数组，得到每一个元素 // i = 1: 直接从第二个元素开始比较，如果 i = 0: 还要自己和自己比，不符合逻辑 for (int i = 1; i < arr.length; i++) { // 判断当前元素 是否大于 首元素 if (arr[i] > max) { // 说明当前元素 大于 首元素，将当前元素 变成 首元素 max = arr[i]; } // 如果没进入if判断，说明当前元素 小于 首元素，则继续遍历，继续判断 } // 循环结束，说明已经比较完了！此时max变量里的值已经是数组中的最大值，返回最大值 return max; } /** * 4、求数组最小值的实现方法 * @param arr 接收一个数组 * @return 返回数组中的最小值 */ private static int arrayMinElement(int[] arr) { // 传入的数组不能为null if (arr == null) { return 0; } // 取出数组中的首元素，用于与其他元素做比较，如果其他元素比这个元素小，就替换 int min = arr[0]; // 遍历数组，得到每一个元素 // i = 1: 直接从第二个元素开始比较，如果 i = 0: 还要自己和自己比，不符合逻辑 for (int i = 1; i < arr.length; i++) { // 判断当前元素 是否小于 首元素 if (arr[i] < min) { // 说明当前元素 小于 首元素，将当前元素 变成 首元素 min = arr[i]; } // 如果没进入if判断，说明当前元素 大于 首元素，则继续遍历，继续判断 } // 循环结束，说明已经比较完了！此时min变量里的值已经是数组中的最小值，返回最小值 return min; } }- 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
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
arr1数组中的最大值是：55 arr2数组中的最小值是：2 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
五、求和并统计个数
-
需求：
- 生成10个1~100之间的随机数存入数组。
- 统计有多少个数据比平均值小？
-
分析：
- 求出所有数据的和
- 求所有数据的平均数
- 统计有多少个数据比平均值小
-
实现：
package com.app.demo10_array_practice; import java.util.Arrays; import java.util.Random; /** 数组的练习 求和并统计个数： 需求：生成10个1~100之间的随机数存入数组。 1、求出所有数据的和 2、求所有数据的平均数 3、统计有多少个数据比平均值小 */ public class ArrayDemo5 { public static void main(String[] args) { // 1、定义一个长度为10的数组 int[] arr = new int[10]; // 2、创建随机数对象，用于生成一个随机数 Random rd = new Random(); // 3、动态生成10个1~100之间的随机数存入数组 for (int i = 0; i < arr.length; i++) { // i = 0 1 2 3 4 5 6 7 8 9 // a.每循环一次，生成一个随机数 int number = rd.nextInt(100) + 1; // b.将生成的随机数存入数组中 arr[i] = number; } // 4、看看数组中的元素 System.out.println("数组：" + Arrays.toString(arr)); // 5、调用求数组中所有数据和的方法 int sum = arrayElementSum(arr); System.out.println("数组中所有数的和：" + sum); // 6、调用求数组中所有数据的平均值的方法，传入一个数组、数组中所有数的和 int average = arrayElementAverage(arr, sum); System.out.println("数组中所有数的平均数(只保留整数部分)：" + average); // 7、调用统计数组中比平均值小的数据的方法，传入一个数组、数组中所有数的平均值 int count = countArrayLessAverage(arr, average); System.out.println("数组中比平均值小的数有" + count + "个~"); } /** * 统计数组中比平均值小的数据 * @param arr 接收一个数组 * @param average 数组中所有数的平均值 * @return 返回数组中比平均值小的数据的统计结果 */ private static int countArrayLessAverage(int[] arr, int average) { // 传入的数组如果为null或传入的平均值小于等于0，则返回-1 if (arr == null || average <= 0) { return -1; } // 定义计数变量，用于记录比平均值小的数据的数量 int count = 0; // 遍历数组，依次得到每一个元素 for (int i = 0; i < arr.length; i++) { // 判断当前元素 是否比 平均值小 if (arr[i] < average) { // 是，开始统计比平均值小的数的数量 count++; } } // 循环结束，说明统计完成，返回统计结果 return count; } /** * 求数组中所有数的平均值 * @param arr 接收一个数组 * @param sum 数组所有数的总和 * @return 返回数组中所有数的平均值 */ private static int arrayElementAverage(int[] arr, int sum) { // 传入的数组如果为null或传入的总和小于等于0，则返回-1 if (arr == null || sum <= 0) { return -1; } // 定义变量，分别用于存储最大值、最小值、计算出来的平均值 int max = arr[0]; int min = arr[0]; // int sum = 0; int average = 0; // 遍历数组，依次得到每一个元素 for (int i = 0; i < arr.length; i++) { // 求出最大值 if (arr[i] > max) { max = arr[i]; } // 求出最小值 if (arr[i] < min) { min = arr[i]; } // 求总和 // sum += arr[i]; } // 循环结束，说明最大值和最小值已经求出来了 // 求平均值：(总和 - 最大值 - 最小值) / 长度-2 // System.out.println("最大值：" + max); // System.out.println("最小值：" + min); // System.out.println("总和：" + sum); average = (sum - max - min) / (arr.length - 2); return average; } /** * 求数组中所有数的和 * @param arr 接收一个数组 * @return 返回数组中所有数的和 */ private static int arrayElementSum(int[] arr) { // 传入的数组如果为null，则返回0 if (arr == null) { return 0; } // 定义求和变量，用于累加数组所有数据的和 int sum = 0; // 遍历数组，依次得到每一个元素 for (int i = 0; i < arr.length; i++) { // 将得到的每一个元素累加起来 sum += arr[i]; } // 循环结束，累加完成，返回求和结果 return sum; } }- 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
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
数组：[84, 41, 81, 84, 66, 43, 39, 79, 46, 24] 数组中所有数的和：587 数组中所有数的平均数(只保留整数部分)：59 数组中比平均值小的数有5个~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
六、交换数据
-
需求：
- 定义一个数组，存入1, 2, 3, 4, 5
- 按照要求交换索引对应的元素。
- 交换前：1,2,3,4,5
- 交换后：5,4,3,2,1
-
实现：
package com.app.demo10_array_practice; import java.util.Arrays; /** 数组的练习 交换数据： 需求：定义一个数组，存入1,2,3,4,5 按照要求交换索引对应的元素 交换前: 1,2,3,4,5 交换后: 5,4,3,2,1 */ public class ArrayDemo6 { public static void main(String[] args) { // 1、定义一个数组，存入1,2,3,4,5 int[] arr = {1,2,3,4,5}; System.out.println("交换前：" + Arrays.toString(arr)); // 2、调用交换数据的方法，传入一个数组 int[] newArr = arraySwapData(arr); System.out.println("交换后：" + Arrays.toString(newArr)); } /** * 数组中交换数据 * @param arr 接收一个数组 * @return 返回交换后的数组 */ private static int[] arraySwapData(int[] arr) { // 传入的数组如果为null if (arr == null) { System.out.println("您传入的参数不能为null!"); }else { // 不为null /** for循环： i: 代表首索引，此时 i=0，就是数组的首索引位置 j: 代表尾索引，此时 j=arr.length-1，就是数组的尾索引位置（数组的最后） i < j: 只要首索引位置 小于 尾索引位置，代表数据还没有交换完，则继续交换； 当首索引位置 不小于 为索引位置时，则交换完毕，结束循环 i++: 首索引往前走 j--: 尾索引往回走 */ for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // 得到当前元素，用临时变量存放起来 int temp = arr[i]; // 开始交换： // 将后一位的元素 放到 当前位置 arr[i] = arr[j]; // 将当前元素 放到 后一位的位置 arr[j] = temp; } // 循环结束，说明数组中所有数据已交换完毕，返回交换后的数组 return arr; } return null; } }- 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
交换前：[1, 2, 3, 4, 5] 交换后：[5, 4, 3, 2, 1] Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
七、打乱数据
-
需求：
- 定义一个数组，存入1~5。
- 要求打乱数组中所有数据的顺序。
-
实现：
package com.app.demo10_array_practice; import java.util.Arrays; import java.util.Random; /** 数组的练习 打乱数据： 需求：定义一个数组，存入1~5 要求打乱数组中所有数据的顺序 */ public class ArrayDemo7 { public static void main(String[] args) { // 1、定义一个数组，存入1~5 int[] numbers = {1, 2, 3, 4, 5}; // 索引 0 1 2 3 4 System.out.println("打乱前：" + Arrays.toString(numbers)); // 2、创建随机数对象，用于生成一个随机索引 Random rd = new Random(); // 3、遍历数组，得到每个元素 for (int i = 0; i < numbers.length; i++) { // 每遍历到一个元素，就生成一个与数组长度一样的(1~5)的随机索引 int index = rd.nextInt(numbers.length); // 用临时变量将遍历到的当前元素存储起来 int temp = numbers[i]; // 开始交换位置： // 随机索引位置的元素 放到 当前索引位置 numbers[i] = numbers[index]; // 当前索引位置的元素 放到 随机索引位置 numbers[index] = temp; } // 4、循环结束，说明所有数据已全部打乱，打印数组内容 System.out.println("打乱后：" + Arrays.toString(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
- 第一次运行：自己多运行几遍就可以看出效果了
打乱前：[1, 2, 3, 4, 5] 打乱后：[2, 5, 4, 3, 1] Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 第二次运行
打乱前：[1, 2, 3, 4, 5] 打乱后：[1, 3, 4, 5, 2] Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 第三次运行
打乱前：[1, 2, 3, 4, 5] 打乱后：[5, 1, 3, 2, 4] Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
-
-
相关阅读:
【数据分享】上海市出租车GPS数据
【leetcode】两句话中的不常见单词 c++
归并分治 归并排序的应用 + 图解 + 笔记
Python进阶（一) - 图形界面编程Tkinter（1）
requestAnimationFrame 和 setTimeout 的区别
计算机毕业设计SSMJava宠物之家【附源码数据库】
宝塔上创建站点
Coremail邮件安全网关：双一流高校背后的邮件安全专家
删除链表的倒数第n个节点的最优算法实现
C语言——C程序编译过程
- 原文地址：https://blog.csdn.net/yelitoudu/article/details/127563343
