Java课程实验报告实验二——一维数组_java一维数组实训报告
赞
踩
一、实验目的
学习一维数组的用法、方法的定义和调用。
二、实验内容
1. 编写程序，读取1-100之间的整数，然后计算每个数出现的次数。假定输入是以0结束的。以下是程序运行示例：
输入1-100之间的整数：2 5 5 4 3 23 2 0 [回车]
2 出现 2 次
3 出现 1 次
4 出现 1 次
5 出现 2 次
23 出现 1 次
2. 编写一个方法，求出整数数组中最小元素的下标。如果这样的元素个数大于1，则返回最小下标。使用下面的方法头：
public static int indexofSmallestElement(double[] array)
编写测试程序，提示用户输入10个数字，调用这个方法，返回最小元素的下标，然后显示这个下标值。
3. 编写程序， 读入10个数并显示互不相同的数（即一个数出现多次，但仅显示一次）。提示，读入一个数，如果它是一个新数，则将它存储在数组中，如果该数已经在数组中，则忽略它。输入之后，数组包含的都是不同的数。以下是运行示例：
输入10个整数：1 2 3 2 1 6 3 4 5 2
互不相同的数为：1 2 3 6 4 5
4. 如果两个数组list1和list2内容相同，那么就说它们是相同的。使用下面的方法头编写一个方法，如果list1和list2是相同的，该方法就返回true：
public static boolean equal(int[ ] list1, int[ ] list2)
编写一个测试程序，提示用户输入两个整数数列，然后显示它们两个是否相同。以下是运行示例。注意输入的第一个数字表示数列中元素的个数。
提示：可考虑使用230-231页Arrays类提供的方法进行组合调用
输入list1： 5 2 5 6 6 1
输入list2： 5 5 2 6 1 6
这两个数列是相同的
输入list1： 5 5 5 6 6 1
输入list2： 5 2 5 6 1 6
这两个数列是不同的
5. (附加题6.31 信用卡号的合法性，可选做)信用卡号遵循下面的模式。一个信用卡号必须是13-16位的整数。它的开头必须是：
4，指visa卡
5，指master卡
37，指American Express卡
6，指Discovery卡
在1954年，IBM的Hans Luhn提出一种算法，该算法可以验证信用卡号的有效性。这个算法在确定输入的卡号是否正确，或者这张信用卡是否能被正确扫描是非常有用的。该方法通常被称为Luhn检测或Mod10 检测，描述如下（假设卡号是4388576018402626）
（1）从右至左对偶数位上的数字翻倍。如果数字翻倍后是一个两位数，那么就将这两位加在一起得到一位数。
2 * 2 = 4
2 * 2 = 4
4 * 2 = 8
1 * 2 = 2
6 * 2 = 12（1+2=3）
5 * 2 = 10（1+0=1）
8 * 2 = 16（1+6=7）
4 * 2 = 8
（2）将第一步得到的所有一位数相加。
4 + 4 + 8 + 2 + 3 + 1 + 7 + 8 = 37
（3）将卡号里从右往左奇数位上所有数字相加。
6 + 6 + 0 + 8 + 0 + 7 + 8 + 3 = 38
（4）将第二步和第三步得到的结果相加。
37 + 38 = 75
（5）如果第四步得到的结果能被10整除，则卡号是合法的，否则是不合法的。
75 % 10 != 0
编写程序，提示用户输入一个long型整数的信用卡号码，显示这个数字是合法还是非法的。使用下面的方法设计程序：
/*Return true if the card number is valid*/ public static boolean isValid(long number) /*Get the result from step 2*/ public static int sumOfDoubleEvenPlace(long number) /*Return this number if it is a single digit, otherwise return the sum of the two digits*/ public static int getDigit(int number) /*Return sum of odd place digits in number*/ public static int sumOfOddPlace(long number) /*Return true if the digit d is a prefix for number*/ public static boolean prefixMatched(long number, int d) /*Return the number of digits in d*/ public static int getSize(long d) /*Return the first k number of digits from number. If the number of digits in number is less than k, return number*/ public static long getPrefix(long number, int k)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
三、实验结果与分析
（1） 计数器实验
1. 实验运行
首先是提示输入1-100的整数，以0为结尾；
然后输入任意个数个1-100的数值（在这里使用含重复的数据）
回车，出现每个数字的计数结果（按升序排列）
对于含多次重复的数据，程序运行无误
对于错误数据，程序进行提示处理并重新输入
2. 结果分析
A.实验思路
首先根据提示输入1-100内的数并存在num数组中（暂定101个数为封顶），在输入的时候判定是否为0，如果为0输入停止；
再从1到100对数组进行遍历查找，只要查找到一个就将该数据存到结果数组中，每查找到一次计数器+1，查找完毕后将计数器结果对应存在计数数组中，如果没查找到就不做任何处理到下一个；
最后将结果数组和计数数组对应输出即可；
B.实验改进
在判断输入是否为0的同时判断数据是否超过范围，如果超过，提示超出范围并重新输入；
实现方式：使用while(true)和break结构
（2） 返回最小下标
1. 实验运行
首先提示输入十个数字
输入
回车
针对有重复最小数值的输入，返回的是index的最小值
2. 结果分析
A.实验思路
首先提示输入十个数字并将其存在数组中；
再调用函数处理，函数内部首先取第一个元素暂定为min，index记为0，再每次取一个元素与min对比，如果小于min则更新min并将index赋成当前下标，否则不处理继续操作，遍历完毕后返回index；
B.实验改进
题目限制，暂无改进；
（3）显示不同的数
1. 实验运行
首先根据提示输入十个数字
输入（含重复数字）
回车
2. 结果分析
A.实验思路
首先确定计数器为不同的数字个数计数，并开一个数组存储不同的数字；
然后根据提示输入数字，对每一个数字进行判断，对已经在储存不同数字的数组进行遍历，如果存在一个数和输入的数相等则不处理继续操作；如果没有相同的数则将输入的数存到数组中；
最后将数组元素输出即可；
B.实验改进
题目限制，暂无改进；
（4）判定相同与否
1. 实验运行
首先根据提示，先输入数字个数，再输入数字内容
输入后，如果个数相同而数字不同，返回不同的提示
如果个数和数字相同，返回相同的提示
如果个数不同，返回不同的提示
2. 结果分析
A.实验思路
首先根据提示，先输入个数，然后创建该数字个数的数组，并将输入的数字内容存到数组中，两个数组均是该操作；
然后调用equal函数判断是否相等；函数内部为对两个数组同时遍历，临界值为个数，如果对应相等则返回true，否则返回false；
最后输出判定结果
B.实验改进
对equal判断时使用java,util.Array模块中的equals函数，简化操作；
（5）（选做）信用卡号的合法性
1. 实验运行
首先根据提示输入一个长整型的信用卡号
再输入信用卡号
如果信用卡不合法，提示不合法
如果信用卡合法，提示合法
如果输入无效，提示输入无效
2. 结果分析
A.实验思路
主函数思路：
根据提示输入长整型信用卡号，先判定是否有效，再对信用卡号的反偶数位和反奇数位求和并判断是否整除10，输出结果；
getSize函数思路：
先取count 为1，在信用卡号除10非0时每存在一次计数器加一，直到除尽，然后返回count；
getPrefix函数思路：
对输入的前缀的位数，减去getSize的长度数并减去前缀数，然后除10操作其次数次，得到的结果即为prefix；
isValid函数思路
判断长度：13-16位，调用getSize函数
判断前缀：3,4,5,37，调用getPrefix函数
getDigit函数
对输入的数判断，如果大于10，将num % 10 + 1的结果返回（即将两位的数字相加，十位数字一定是1）；否则返回原值
sumOfDoubleEvenPlace函数思路：
首先除10到第二位；
然后模10取最后一位，判断是否是两位数（调用getDigit函数），返回值后将其加到sum上，除去100得到下两位的数，重复操作直到除尽，返回sum；
sumOfOddPlace函数思路：
同sumOfDoubleEvenPlace函数思路但不用进行getDigit判断
B.实验改进
使用while(true)，break结构实现长时间处理，输入0时结束操作；
四、心得体会
在实验编码过程中，在实验一上刚开始我的思路是有误的，我的思路是每输入一个数就进行一次计数，这样可以减少遍历次数，但是结果是不能按照题中输出格式升序输出，因此转换方法遍历，而在第五题时刚开始思路不是特别清晰，通过列图的方式将函数联系分析之后便可以将模块分清，接下来只是对每个操作的处理，这种方法确实可以使思路更为简洁，而且模块化处理减少了错误的范围；
实验的过程使我对Java数组的基础操作进一步熟悉，同时也温习了之前学到的循环选择等基础结构，收获颇丰；
实验的难度在逐步上升，需要进一步熟悉操作，提高代码水平；
【源代码】
Experiment1 import java.util.Scanner; public class experiment1 { private static Scanner input; public static void main(String[] args){ //持续输入操作 while(true){ int[] num = new int[101]; input = new Scanner(System.in); System.out.println("输入1-100之间的整数，以0为结尾："); int i = 0; //初始条件 boolean jud = true; //输入并判断数字类型，如果0结束，如果超范围输入错误 while(true){ num[i] = input.nextInt(); if(num[i] < 0 || num[i] > 100)jud = false; if(num[i] == 0)break; i++; } if(jud){ int[] re = new int[101]; int[] co = new int[101]; int temp = 0; //对1-100进行操作 for(int j = 1;j <= 100;j++){ int n = 0; //遍历数组并计数 for(int k = 0;k < i;k++){ if(num[k] == j){ if(n == 0){ re[temp] = j; temp++; } n++; } } if(n > 0)co[temp-1] = n; } //输出 for(int j = 0; j < temp;j++){ System.out.println(re[j] + "出现" + co[j] + "次"); } break; } else System.out.println("数据类型错误，处理失败"); continue; } } } Experiment2 import java.util.Scanner; public class experiment2 { public static int indexofSmallestElement(double[] array){ double min; int index = 0; //将最前面的元素初始成min min = array[0]; //比较操作 for(int i = 2;i < 10;i++){ if(array[i] < min){ min = array[i]; index = i; } } return index; } public static void main(String[] args) { double[] num = new double[10]; Scanner input = new Scanner(System.in); System.out.print("输入十个数字"); for(int i = 0;i < 10;i++){ num[i] = input.nextDouble(); } int result = indexofSmallestElement(num); System.out.println("最小元素的下标为" + result); } } Experiment3 import java.util.Scanner; public class experiment3 { public static void main(String[] args) { Scanner input = new Scanner(System.in); int[] num = new int[10]; System.out.print("输入十个数："); int count = 0,n = 0; while (true) { boolean jud = true; int temp = input.nextInt(); n++; //对输入的数，遍历数组，如果有相同跳出 for (int i = 0; i < count; i++) { if (num[i] == temp) { jud = false; break; } } //不同时的处理 if (jud) { num[count] = temp; count++; } if(n == 10)break; } System.out.print("互不相同的数为："); for(int j = 0;j < count;j++){ System.out.print(num[j] + " "); } } } Experiment4 import java.util.Scanner; public class experiment4 { public static boolean equal(int[] list1, int[] list2){ //比较操作 return java.util.Arrays.equals(list1,list2); } public static void main(String[] args) { int m,n; Scanner input = new Scanner(System.in); System.out.print("输入list1，首先输入数字个数，再输入数字内容: "); m = input.nextInt(); int[] list1 = new int[m]; for(int i = 0; i < m;i++){ list1[i] = input.nextInt(); } System.out.print("输入list2，首先输入数字个数，再输入数字内容: "); n = input.nextInt(); int[] list2 = new int[n]; for(int i = 0; i < m;i++){ list2[i] = input.nextInt(); } System.out.print("这两个数组是"); if(equal(list1, list2))System.out.print("相同的"); if(!equal(list1, list2))System.out.print("不同的"); } } Experiment5 import java.util.Scanner; public class experiment5 { /*Return the number of digits in d*/ public static int getSize(long d){ int count = 1; while(d / 10 != 0){ d /= 10; count++; } return count; } /*Return the first k number of digits from number. If the number of digits in number is less than k, return number*/ public static long getPrefix(long number, int k){ int index = getSize(number) - k; for(int i =0; i < index;i++)number /= 10; return number; } /*Return true if the card number is valid*/ public static boolean isValid(long number){ if(getSize(number)>= 13 && getSize(number)<= 16 && (getPrefix(number, 1) == 4 || getPrefix(number, 1)== 5 || getPrefix(number, 1)== 6 || getPrefix(number, 2)==37)) return true; else return false; } /*Return this number if it is a single digit, otherwise return the sum of the two digits*/ public static int getDigit(int number){ int re = 0; if(number >= 10){ re = number % 10 + 1; } else re = number; return re; } /*Get the result from step 2*/ public static int sumOfDoubleEvenPlace(long number){ number /= 10; int sum = 0; while(number != 0){ int temp = (int) (number % 10 * 2); sum += getDigit(temp); number /= 100; } return sum; } /*Return sum of odd place digits in number*/ public static int sumOfOddPlace(long number){ int sum = 0; while(number != 0){ sum += number % 10; number /= 100; } return sum; } public static void main(String[] args){ //持续输入 while(true){ Scanner input = new Scanner(System.in); System.out.println("请输入一个长整型的信用卡号,以0结束"); long num = input.nextLong(); if(num == 0){ System.out.println("程序结束"); break; } int size = getSize(num); //当有效时，将奇偶数结果相加进行判断 if(isValid(num)){ int sum1 = sumOfDoubleEvenPlace(num); int sum2 = sumOfOddPlace(num); int sum = sum1+sum2; if(sum % 10 == 0)System.out.println("这个卡号是合法的"); else System.out.println("这个卡号是不合法的"); } //当无效时，提示 else System.out.println("这个卡号是无效的"); } } }
- 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
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
