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） 计数器实验
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("这个卡号是无效的");
	}
	}
}