一、实验目的
学习一维数组的用法、方法的定义和调用。
二、实验内容
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） 计数器实验
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("这个卡号是无效的");
}
}
}
