Java学习记录_1：MOOC《零基础学Java语言》课后习题解

Hey，我是寒水，一名大二学生，电子商务专业在读，正在学习Java中。我试图将在Java学习中遇到的一些困惑和最终的解答发在这个账号上，希望以此来激励我不要放弃学习！

在学习记录这个专题中，我收藏一些我在网课以及学校课程中学到的经典案例或习题，供自己也供大家参考。浙江大学翁恺老师在MOOC上的《零基础学Java语言》和《面向对象程序设计——Java语言》可以说是我在Java学习中的入门课程，十分经典，因此我将其作为这个专题的第一部分。在这篇博客中，我将分享在《零基础学Java语言》中的课后习题以及自己的理解和答案。

第一周 计算

1. 温度转换

这里是写一个将华氏温度转换成摄氏温度的程序，转换的公式是：
·
°F = (9/5)*°C + 32
·
其中C表示摄氏温度，F表示华氏温度。
·
程序的输入是一个整数，表示华氏温度。输出对应的摄氏温度，也是一个整数。
·
提示，为了把计算结果的浮点数转换成整数，需要使用下面的表达式：
·
(int)x;
·
其中x是要转换的那个浮点数。

思路：写出表达式，正常描述即可。

import java.util.*;

public class homework {

	public static void main(String[] args) {
			
		System.out.println("请输入一个华氏温度。");
		Scanner cin=new Scanner(System.in);
		double Fah =cin.nextDouble(),Tem;
		Tem=(Fah-32)/(9.0/5);
		int tem1=(int)Tem;
		System.out.println(tem1);

	}

}

第二周 判断

1. 温度转换

UTC是世界协调时，BJT是北京时间，UTC时间相当于BJT减去8。现在，你的程序要读入一个整数，表示BJT的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果分小于10分，需要保留十位上的0。如1124表示11点24分，而905表示9点5分，36表示0点36分，7表示0点7分。
·
有效的输入范围是0到2359，即你的程序不可能从测试服务器读到0到2359以外的输入数据。
·
你的程序要输出这个时间对应的UTC时间，输出的格式和输入的相同，即输出一个整数，表示UTC的时和分。整数的个位和十位表示分，百位和千位表示小时。如果小时小于10，则没有千位部分；如果小时是0，则没有百位部分；如果分小于10分，需要保留十位上的0。
·
提醒：要小心跨日的换算。

思路：输入北京时间，正常计算世界协调时。特殊的隔天时间通过IF判断来表明。

import java.util.*;

public class homework1 {
public static void main(String[] args) {
	Scanner cin=new Scanner(System.in);
	int bjt=cin.nextInt();
		if(bjt>2359||bjt<0) {
			System.out.println("有误！");
		}
		else {
			int utc=0;
			if(bjt/100>=8) {
				utc=((bjt/100)-8)*100+(bjt-bjt/100*100);
				System.out.println(utc);
			}
			else {
				utc=(24-(8-bjt/100))*100+(bjt-bjt/100*100);
				System.out.println("昨日"+utc);
			}
		}
	}
}

2. 信号判断

无线电台的RS制信号报告是由三两个部分组成的：
·
R(Readability) 信号可辨度即清晰度.
·
S(Strength) 信号强度即大小.
·
其中R位于报告第一位，共分5级，用1—5数字表示.
·
1—Unreadable
·
2—Barely readable, occasional words distinguishable
·
3—Readable with considerable difficulty
·
4—Readable with practically no difficulty
·
5—Perfectly readable
·
报告第二位是S，共分九个级别，用1—9中的一位数字表示
·
1—Faint signals, barely perceptible
·
2—Very weak signals
·
3—Weak signals
·
4—Fair signals
·
5—Fairly good signals
·
6—Good signals
·
7—Moderately strong signals
·
8—Strong signals
·
9—Extremely strong signals
·
现在，你的程序要读入一个信号报告的数字，然后输出对应的含义。如读到59，则输出：
·
Extremely strong signals, perfectly readable.

思路：通过switch函数，将不同数字转化为不同信号，再输出即可。

import java.util.*;

public class homework1 {

	public static void main(String[] args) {
	
		Scanner cin=new Scanner(System.in); 
		int RS=cin.nextInt();
		String R="1",S="1";
		switch(RS/10){
			case 1:
				R=", unreadable";
				break;
			case 2:
				R=", barely readable, occasional words distinguishable";
				break;
			case 3:
				R=", readable with considerable difficulty";
				break;
			case 4:
				R=", readable with practically no difficulty";
				break;
			case 5:
				R=", perfectly readable";
				break;
		}
		switch(RS-RS/10*10) {
			case 1:
				S="Faint signals, barely perceptible";
				break;
			case 2:
				S="Very weak signals";
				break;
			case 3:
				S="Weak signals";
				break;
			case 4:
				S="Fair signals";
				break;
			case 5:
				S="Fairly good signals";
				break;
			case 6:
				S="Good signals";
				break;
			case 7:
				S="Moderately strong signals";
				break;
			case 8:
				S="Strong signals";
				break;
			case 9:
				S="Extremely strong signals";	
				break;
			}
			System.out.println(S+R);
		}
	}

第三周 循环

1. 奇偶个数

你的程序要读入一系列正整数数据，输入-1表示输入结束，-1本身不是输入的数据。程序输出读到的数据中的奇数和偶数的个数。

思路：设置奇数和偶数两个变量，遍历循环时检索正整数数据，再逐一增加变量即可。

import java.util.*;

public class homework3 {

	public static void main(String[] srgs) {
			Scanner input=new Scanner(System.in);
			int odd=0,even=0;
			while(true) {
				int num=input.nextInt();
				if (num==-1) {
					break;
				}
				else if(num%2==0) {
					even+=1;
				}	
				else {
					odd+=1;
				}
			}
		System.out.printf("奇数有%d个，偶数有%d个",odd,even);
	}
}

2. 数字特征值

对数字求特征值是常用的编码算法，奇偶特征是一种简单的特征值。对于一个整数，从个位开始对每一位数字编号，个位是1号，十位是2号，以此类推。这个整数在第n位上的数字记作x，如果x和n的奇偶性相同，则记下一个1，否则记下一个0。按照整数的顺序把对应位的表示奇偶性的0和1都记录下来，就形成了一个二进制数字。比如，对于342315，这个二进制数字就是001101。
·
按照二进制位值将1的位的位值加起来就得到了结果13。

·
你的程序要读入一个非负整数，整数的范围是[0,100000]，然后按照上述算法计算出表示奇偶性的那个二进制数字，输出它对应的十进制值。

·
提示：将整数从右向左分解，数位每次加1，而二进制值每次乘2。

思路：通过循环检索即可得到答案。

import java.util.*;

public class homework3 {

	public static void main(String[] srgs) {
	
		Scanner cin=new Scanner(System.in);
		int digit=1,result=0;
		long num=cin.nextInt();
		String num1=(num+"");
		for(;digit<=num1.length();digit++) {
			if(num1.charAt(num1.length()-digit)%2==digit%2){
				result+=Math.pow(2, digit-1);
			}
		}
		System.out.println(result);
	}
}

第四周 循环控制

1. 素数和

我们认为2是第一个素数，3是第二个素数，5是第三个素数，依次类推。
·
现在，给定两个整数n和m，0 ·
注意，是第n个素数到第m个素数之间的所有的素数，并不是n和m之间的所有的素数。

思路：我的思路是设置类计算素数，再在输入的起始和终止数之间计算素数和。

 import java.util.*;

	
	class Demo{
		int e;
		public Demo(int e) {
			this.e=e;
		}
		public int odd(){
		
			int b=0,c=0,d=0;
	 		
			for(int a=2;;a++) {
	 			b=a-1;
	 			do {	
	 				c=a%b;
	 				b--;
	 			}while(c!=0);
		
	 			if(b==0) {
				d+=1;
	 			}
			
				if(d==e) {
					return a;
				}
			}
		}
	}
	
 	public class homework4 {
 		public static void main(String[] args) {

 			Scanner cin=new Scanner(System.in);
 			System.out.print("请输入起始数：");
 			int a=cin.nextInt();
 			System.out.print("请输入末尾数：");
 			int b=cin.nextInt(),sum=0;
 			for(;a<=b;a++) {
 				Demo first=new Demo(a);
 				sum+=first.odd();
 			}
 			System.out.println(sum);
 		}
 	}

2. 念整数

你的程序要读入一个整数，范围是[-100000,100000]。然后，用汉语拼音将这个整数的每一位输出出来。
·
如输入1234，则输出：
·
yi er san si
·
注意，每个字的拼音之间有一个空格，但是最后的字后面没有空格。当遇到负数时，在输出的开头加上“fu”，如-2341输出为：
·
fu er san si yi

思路：先用switch实现让程序能翻译不同的数字，在考虑数字间的空格问题。

 import java.util.*;

 	public class homework4 {
 		public static void main(String[] args) {
 		
 			Scanner cin=new Scanner(System.in);
 			int num=cin.nextInt();
 			String[] shu=new String[(num+"").length()];

 			
 			if(num<0) { 
 				System.out.print("fu"+" ");
 				num=-num;
 			}
 			int a=num;
 			for(int c=0;c<(a+"").length();c++) {

 				switch(num%10){
	 				case 0:shu[c]="ling";
	 				break;
	 				case 1:shu[c]="yi";
	 				break;
	 				case 2:shu[c]="er";
	 				break;
	 				case 3:shu[c]="san";
	 				break;
	 				case 4:shu[c]="si";
	 				break;
	 				case 5:shu[c]="wu";
	 				break;
	 				case 6:shu[c]="liu";
	 				break;
	 				case 7:shu[c]="qi";
	 				break;
	 				case 8:shu[c]="ba";
	 				break;
	 				case 9:shu[c]="jiu";
	 				break;
 				}
 				num/=10;
 			}
 			

 			for(int d=(a+"").length()-1;d>=0;d--) {
 				if(d==(a+"").length()-1) {
 					System.out.print(shu[d]);
 				}
 				else {
 					System.out.print(" "+shu[d]);
 				}
 				
 			}

 		}
 	}

第五周 数组

1. 多项式加法

一个多项式可以表达为x的各次幂与系数乘积的和，比如：
·
2x6+3x5+12x3+6x+20
·
现在，你的程序要读入两个多项式，然后输出这两个多项式的和，也就是把对应的幂上的系数相加然后输出。
·
程序要处理的幂最大为10

思路：输入两个多项式，比较孰长，再将长数组逐一与短数组相加，可得。

	import java.util.*;

	public class homework6 {
		public static void main(String[] args) {
			Scanner cin = new Scanner(System.in);
	        int[] a,b; 
	        int max=0; 
	        System.out.print("请输入第一个幂：");
	        int n=cin.nextInt(); 
	        System.out.print("请输入第一个系数：");
	        int x=cin.nextInt(); 
	        a=new int[n+1]; 
	        a[n]=x;
	        do {
		        System.out.print("请输入接下来的幂：");
	            n=cin.nextInt(); 
		        System.out.print("请输入接下来的系数：");
	            x=cin.nextInt(); 
	            a[n]=x;  
	        }while(n!=0); 
	        
	        System.out.print("请输入第二个多项式的第一个幂：");		//第二个多项开始
	        n=cin.nextInt();
	        System.out.print("请输入第二个多项式的第一个系数：");
	        x=cin.nextInt();
	        b=new int[n+1];
	        do{
	        	System.out.print("请输入接下来的幂：");
	            n=cin.nextInt();
	            System.out.print("请输入接下来的系数：");
	            x=cin.nextInt();
	            b[n]=x;     
	        }while(n!=0);
	         
	        if(a.length>b.length){		//计算数组长度
	            max=a.length;
	        }
	        else{
	            max=b.length;
	        }
	        for(int j=max-1;j>=0;j--){
		        int sum=0;
		        if(j1){
		            System.out.print(sum+"x"+j+"+");
		        }
		        else if(j==0){
		            System.out.print(sum);
		        } 
		        else if(j==1){
		            System.out.print(sum+"x"+"+");
		        }
	        }
			
		}
	}

第六周 使用对象

1. 多项式加法

你的程序要读入一行文本，其中以空格分隔为若干个单词，以‘.’结束。你要输出这行文本中每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如“it’s”算一个单词，长度为4。注意，行中可能出现连续的空格。

思路：从字符串开始处计数，遇到空格初始化，再此循环，遇到.停止计数并输出即可。

 import java.util.*;
 
 public class homework7{
	 
	 public static void main(String[] args) {
	
		 System.out.println("请输入一段文本，并以“.”结尾。");
		 Scanner cin=new Scanner(System.in);
		 String art=cin.nextLine();
		 int b=0;
		 
		 for(int a=0;a

2. GPS信号处理

NMEA-0183协议是为了在不同的GPS（全球定位系统）导航设备中建立统一的BTCM（海事无线电技术委员会）标准，由美国国家海洋电子协会（NMEA-The> National Marine Electronics> Associa-tion）制定的一套通讯协议。GPS接收机根据NMEA-0183协议的标准规范，将位置、速度等信息通过串口传送到PC机、PDA等设备。
·

NMEA-0183协议是GPS接收机应当遵守的标准协议，也是目前GPS接收机上使用最广泛的协议，大多数常见的GPS接收机、GPS数据处理软件、导航软件都遵守或者至少兼容这个协议。
·

NMEA-0183协议定义的语句非常多，但是常用的或者说兼容性最广的语句只有$GPGGA、$GPGSA、$GPGSV、$GPRMC、$GPVTG、$GPGLL等。
·

其中$GPRMC语句的格式如下：

·

$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,A*50

·

这里整条语句是一个文本行，行中以逗号“,”隔开各个字段，每个字段的大小（长度）不一，这里的示例只是一种可能，并不能认为字段的大小就如上述例句一样。

·
字段0：$GPRMC，语句ID，表明该语句为Recommended Minimum Specific GPS/TRANSIT
Data（RMC）推荐最小定位信息
·
字段1：UTC时间，hhmmss.sss格式

字段2：状态，A=定位，V=未定位

字段3：纬度ddmm.mmmm，度分格式（前导位数不足则补0）

字段4：纬度N（北纬）或S（南纬）

字段5：经度dddmm.mmmm，度分格式（前导位数不足则补0）

字段6：经度E（东经）或W（西经）

字段7：速度，节，Knots

字段8：方位角，度

字段9：UTC日期，DDMMYY格式

字段10：磁偏角，（000 - 180）度（前导位数不足则补0）

字段11：磁偏角方向，E=东W=西

字段16：校验值
·

这里，“”为校验和识别符，其后面的两位数为校验和，代表了“$”和“”之间所有字符（不包括这两个字符）的异或值的十六进制值。上面这条例句的校验和是十六进制的50，也就是十进制的80。

·
提示：^运算符的作用是异或。将$和之间所有的字符做^运算(第一个字符和第二个字符异或，结果再和第三个字符异或，依此类推)之后的值对65536取余后的结果，应该和后面的两个十六进制数字的值相等，否则的话说明这条语句在传输中发生了错误。注意这个十六进制值中是会出现A-F的大写字母的。另外，如果你需要的话，可以用Integer.parseInt(s)从String变量s中得到其所表达的整数数字；而Integer.parseInt(s,> 16)从String变量s中得到其所表达的十六进制数字
·

现在，你的程序要读入一系列GPS输出，其中包含$GPRMC，也包含其他语句。在数据的最后，有一行单独的END表示数据的结束。
`

你的程序要从中找出$GPRMC语句，计算校验和，找出其中校验正确，并且字段2表示已定位的语句，从中计算出时间，换算成北京时间。一次数据中会包含多条$GPRMC语句，以最后一条语句得到的北京时间作为结果输出。
`

你的程序一定会读到一条有效的$GPRMC语句。

思路：将长GPS信号拆分成片段，并对不同片段加以详细分析，即可得解。

	import java.util.*;
	
		public class homework8 {
			
		public static void main(String[] args) {
			
			System.out.println("请输入一列GPS定位,并以END结尾。");
			Scanner cin=new Scanner(System.in);
			String words=cin.nextLine();
			String sure;
			sure=cin.nextLine();
			if(!sure.equals("END")) {
//				System.out.println("请输入END结尾！");
				do{
					System.out.println("请输入END结尾！");
					sure=cin.nextLine();
				}while(!sure.equals("END"));
			}
			
			int num=Integer.parseInt("50",16);
//			System.out.println(num);
			int b=0;
			for(int a=1;a=24) {
				hour-=24;
			}
			String m=words.substring(words.indexOf(',')+3,words.indexOf(',')+5);
			int min=Integer.parseInt(m);
			String s=words.substring(words.indexOf(',')+5,words.indexOf(',')+7);
			int si=Integer.parseInt(s);
			System.out.printf("%02d:%02d:%02d",hour,min,si);
			System.out.print("\n");
		}
		
	}
			

第七周 函数

1. 分解质因数

每个非素数（合数）都可以写成几个素数（也可称为质数）相乘的形式，这几个素数就都叫做这个合数的质因数。比如，6可以被分解为2x3，而24可以被分解为2x2x2x3。
·
现在，你的程序要读入一个[2,100000]范围内的整数，然后输出它的质因数分解式；当读到的就是素数时，输出它本身。

思路：设计函数检测数字能否再次分解，类似递归算法。

import java.util.*;

		public class homework9 {
			public static void main(String[] args) {
				Scanner cin =new Scanner(System.in);
				int input=cin.nextInt();
				int input1=input;
				int andnum=0;
				int oddnum=0;
				
				S:
				for(int a=input1-1;a>=1;a--) {
						if(input1%a==0&&a!=1) {
							andnum=input;
							System.out.print(input+"=");
							break S;
						}
						if(input1%a==0&&a==1) {
							System.out.println(input+"="+input);
							break S;
						}
				}
								//判断input是否是质数
				

				for(int a=2;a<=1000;a++) {
					int b=a-1;
					do {
						if(a%b==0&&b!=1) {
							break;
						}
						if(a%b==0&&b==1) {
							oddnum+=1;
						}
						b--;
					}while(b!=0);
				}
				
				int []odd=new int[oddnum];
				int begin=0;

				for(int a=2;a<=1000;a++) {
					int b=a-1;
					do {
						if(a%b==0&&b!=1) {
							break;
						}
						if(a%b==0&&b==1) {
							odd[begin]=a;
									begin++;
						}
						b--;
					}while(b!=0);
				}	
				
				if(andnum!=0) {
					for(int a=0;a<=oddnum-1;a++) {
						while(andnum%odd[a]==0) {
							andnum/=odd[a];
							if(andnum!=1) {
								System.out.print(odd[a]+"*");
							}
							if(andnum==1) {
								System.out.print(odd[a]);
							}
						}
						if(andnum==1) {
							break;
						}
					}
				}
		}
	}
					

1. 完数

一个正整数的因子是所有可以整除它的正整数。而一个数如果恰好等于除它本身外的因子之和，这个数就称为完数。例如6=1＋2＋3(6的因子是1,2,3)。
·
现在，你要写一个程序，读入两个正整数n和m（1<=n

思路：输入起始值和终止值，并写出计算是否为完数的函数，逐一验证即可。

import java.util.*;

public class homework10 {
	public static void main(String[] args) {
		
		Scanner cin=new Scanner(System.in);
		int begin=cin.nextInt();
		int fina=cin.nextInt();
		int add=0;
		
		for(;begin<=fina;begin++) {
			for(int a=1;a

期末考试 二进制的前导零

计算机内部用二进制来表达所有的值。一个十进制的数字，比如18，在一个32位的计算机内部被表达为00000000000000000000000000011000。可以看到，从左边数过来，在第一个1之前，有27个0。我们把这些0称作前导的零。
·
现在，你的任务是写一个程序，输入一个整数，输出在32位二进制表达下它前导的零的个数。

思路：输入数字，设计函数计算数字能被2整除的次数，次数即答案。

import java.util.*;
	public class exam{  
		public static void main(String[] args) {
			
			Scanner cin=new Scanner(System.in);
			int num=cin.nextInt();
			int number=0;
			while(num!=0) {
				num/=2;
				number++;
			}
			System.out.println(32-number);
		}
	}

以上便是所有关于《零基础学Java》的例题与答案，之后在这个专题里我将会分享《面向对象程序设计——Java语言》的例题与答案以及更多课程与参考书，感谢阅读:+)