（1）前言：
第一次题目集主要让我们熟悉了Java的语法，格式，以及简单的应用方式，难度比较简单，但是相对的题量比较大，在对于当时初学Java的我们来说还是要认真对待的。
第二次题目集在第一次题目集的难度上提升较大，但是还是在自学有关知识后还是可以处理的，学习了浮点数保留小数的相关知识，（浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365），日期类的基本应用方法，类的封装方法等知识，提升了自身的编程水平。
第三次题目集是目前遇到的最难的一次题目，第一次切身感受到了Java的难度，认识到了自身的不足，需要更加努力的学习才可以完成安排的学习任务。
（2）设计与分析：
题目集一：
体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。
输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；
输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。
代码如下：
import java.util.Scanner;
import static java.lang.Math.pow;
public class Main {
public static void main(String[] args) {
double height,weight,BMI;
Scanner person = new Scanner(System.in);
weight = person.nextDouble();
height = person.nextDouble();
BMI = weight / pow(height,2);
if(weight<=0||height<=0||weight>727||height>2.72)
{
System.out.println("input out of range");
return;
}
else if(BMI>=28)
{
System.out.println("fat");
return;
}
else if(BMI>=24&&BMI<28)
{
System.out.println("overweight");
return;
}
else if(BMI>=18.5&&BMI<24)
{
System.out.println("fit");
return;
}
else if(BMI<18.5)
{
System.out.println("thin");
return;
}
}
}
一共有十个测试点，其中在测试边界数值时，容易出现错误。
题目集二：
创建学生类，包含
属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）
方法：计算总分、计算平均分
输入5个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80
22201312 黄昊 66 82 81
22201313 李少辰 77 76 80
22201314 袁婷 62 79 90
22201315 朱哲一 74 98 94
输出格式:
5个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 240 80.00
22201312 黄昊 229 76.33
22201313 李少辰 233 77.67
22201314 袁婷 231 77.00
22201315 朱哲一 266 88.67
代码如下：
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import java.util.Scanner;
import java.text.DecimalFormat;
class Student {
//属性
String Number; //学号
String Name; //姓名
int chineseGrades; //语文成绩
int mathGrades; //数学成绩
int physicsGrades; //物理成绩
//构造方法
public Student() {
}
public Student(String number, String name, int chineseGrades, int mathGrades, int physicsGrades) {
Number = number;
Name = name;
this.chineseGrades = chineseGrades;
this.mathGrades = mathGrades;
this.physicsGrades = physicsGrades;
}
public void Output() {
int totalScore = chineseGrades + mathGrades + physicsGrades;
double averageScore = (double) totalScore / 3;
DecimalFormat df = new DecimalFormat("#.00");
System.out.println(Number + " " + Name + " " + totalScore + " " + df.format(averageScore));
}
}
public class Main {
public static void main(String[] args) {
int i,j;
Scanner sc = new Scanner(System.in);
Student[] students = new Student[5]; //创建一个包含5个学生对象的数组
//输入5个学生的信息
for (i = 0; i < 5; i++) {
String number = sc.next();
String name = sc.next();
int chineseGrades = sc.nextInt();
int mathGrades = sc.nextInt();
int physicsGrades = sc.nextInt();
students[i] = new Student(number,name,chineseGrades,mathGrades,physicsGrades);
}
//输出每个学生的信息
for (j = 0; j < students.length; j++) {
students[j].Output();
}
}
}
本题在输出时容易出现格式错误的问题，需要仔细观察题目给出的例子，并对输出结果进行修正，以此输出正确格式的代码。
输入3个学生的信息，将每个学生的信息封装在一个学生对象中。
按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365
注意：未用学生类对象封装数据的，本题计0分
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：
学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致
例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出格式:
3个学生信息，每个学生信息格式：
学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分
例如：
22201311 张琳 242 80.67
22201312 黄昊 234 78.00
22201313 李少辰 236 78.67
输入样例:
在这里给出一组输入。例如：
22201311 张琳 语文 70 80
22201311 张琳 数学 85 89
22201311 张琳 物理 75 83
22201312 黄昊 语文 66 78
22201312 黄昊 数学 76 82
22201312 黄昊 物理 83 82
22201313 李少辰 语文 86 76
22201313 李少辰 数学 78 76
22201313 李少辰 物理 87 76
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 242 76.67 84.00 80.67
22201312 黄昊 234 75.00 80.67 78.00
22201313 李少辰 236 83.67 76.00 78.67代码如下：
import java.text.DecimalFormat;
import java.util.Scanner;
class Student {
String studentNumber;
String name;
studentGrades chineseGrades;
studentGrades mathGrades;
studentGrades physicsGrades;
public Student(String studentNumber, String name) {
this.studentNumber = studentNumber;
this.name = name;
}
public void setGrades(String examCourse, int dailyGrades, int examGrades) {
switch (examCourse) {
case "语文":
chineseGrades = new studentGrades(dailyGrades, examGrades);
break;
case "数学":
mathGrades = new studentGrades(dailyGrades, examGrades);
break;
case "物理":
physicsGrades = new studentGrades(dailyGrades, examGrades);
break;
default:
break;
}
}
public double averageGrades() {
int totalGrades = totalGrades();
return (double) totalGrades / 3;
}
public int totalGrades() {
int totalGrades = 0;
totalGrades = chineseGrades.totalGrades()+mathGrades.totalGrades()+physicsGrades.totalGrades();
return totalGrades;
}
public double calculateDailyGradesAverage() {
double dailyGradesINTotal = 0;
int count = 0;
if (chineseGrades != null) {
dailyGradesINTotal += chineseGrades.dailyGrades;
count++;
}
if (mathGrades != null) {
dailyGradesINTotal += mathGrades.dailyGrades;
count++;
}
if (physicsGrades != null) {
dailyGradesINTotal += physicsGrades.dailyGrades;
count++;
}
return count > 0 ? dailyGradesINTotal / count : 0;
}
public float doubleGrades(){
int doubleGrades = (int) doubleGrades();
Object totalGrades = new Object();
return (float) ((double) totalGrades / 3);
}
// public void Output() {
// int totalGrades = totalGrades();
// double averageGrades = averageGrades();
// DecimalFormat dK = new DecimalFormat("#.00");
// System.out.println(studentNumber + " " + name + " " + totalGrades + " " + dK.format(averageGrades));
// }
public double calculateExamGradesAverage() {
double examGradesINTotal = 0;
int count = 0;
if (chineseGrades != null) {
examGradesINTotal += chineseGrades.examGrades;
count++;
}
if (mathGrades != null) {
examGradesINTotal += mathGrades.examGrades;
count++;
}
if (physicsGrades != null) {
examGradesINTotal += physicsGrades.examGrades;
count++;
}
return count > 0 ? examGradesINTotal / count : 0;
}
public void Output() {
int totalGrades = totalGrades();
double averageScore = averageGrades();
double dailyGradesAverage = calculateDailyGradesAverage();
double examGradesAverage = calculateExamGradesAverage();
DecimalFormat dK = new DecimalFormat("#.00");
System.out.println(studentNumber + " " + name + " " + totalGrades + " " + dK.format(dailyGradesAverage) + " " + dK.format(examGradesAverage) + " " + dK.format(averageScore));
}
}
class studentGrades {
int dailyGrades; // 平时成绩
int examGrades; // 期末成绩
public studentGrades(int dailyGrades, int examGrades) {
this.dailyGrades = dailyGrades;
this.examGrades = examGrades;
}
public float doubleGrades(){
int doubleGrades = (int) doubleGrades();
Object totalGrades = new Object();
return (float) ((double) totalGrades / 3);
}
public int totalGrades() {
return (int) (dailyGrades * 0.4 + examGrades * 0.6);
}
}
public class Main {
public static void main(String[] args) {
int a,b,c;
Scanner scanner = new Scanner(System.in);
Student[] students = new Student[3];
for (a = 0; a < 9; a++) {
String input = scanner.nextLine();
String[] Label = input.split(" ");
int examGrades = Integer.parseInt(Label[4]);
int dailyGrades = Integer.parseInt(Label[3]);
String examCourse = Label[2];
String name = Label[1];
String studentNumber = Label[0];
int ifExist = 0;
for (b = 0; b < 3; b++) {
if (students[b] != null && students[b].studentNumber.equals(studentNumber)) {
students[b].setGrades(examCourse, dailyGrades, examGrades);
ifExist = 1;
break;
}
}
if (ifExist!=1) {
for (c = 0; c < 3; c++) {
if (students[c] == null) {
students[c] = new Student(studentNumber, name);
students[c].setGrades(examCourse, dailyGrades, examGrades);
break;
}
}
}
}
for (Student student : students) {
if (student != null) {
student.Output();
}
}
}
}
本题与7-1类似，在输入时的输入内容与方式有所不同，相对于7-1来说更加复杂，在输出时容易出现格式错误的问题，需要仔细观察题目给出的例子，并对输出结果进行修正，以此输出正确格式的代码。
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist
48import static java.lang.Math.pow;
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.Set;
import java.util.HashSet;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
String foodIndish;
String []existMenu = new String[]{"清炒土豆丝","西红柿炒蛋","油淋生菜","麻婆豆腐"};
String Stop = "end";
int outputPrice, Heft;
outputPrice = 0;
while(true)
{
boolean Flag = false;
foodIndish = in.next();
if(foodIndish.equals("end"))
{
break;
}
Heft=in.nextInt();
if(foodIndish.equals("西红柿炒蛋"))
{
Flag = true;
switch (Heft)
{
case 1:
outputPrice = outputPrice+15;
break;
case 2:
outputPrice = outputPrice+23;
break;
case 3:
outputPrice = outputPrice+30;
break;
default:
break;
}
}
else if(foodIndish.equals("清炒土豆丝"))
{
Flag = true;
switch (Heft)
{
case 1:
outputPrice = outputPrice+12;
break;
case 2:
outputPrice = outputPrice+18;
break;
case 3:
outputPrice = outputPrice+24;
break;
default:
break;
}
}
else if(foodIndish.equals("麻婆豆腐"))
{
Flag = true;
switch (Heft)
{
case 1:
outputPrice = outputPrice+12;
break;
case 2:
outputPrice = outputPrice+18;
break;
case 3:
outputPrice = outputPrice+24;
break;
default:
break;
}
}
else if(foodIndish.equals("油淋生菜"))
{
Flag = true;
switch (Heft)
{
case 1:
outputPrice = outputPrice+9;
break;
case 2:
outputPrice = outputPrice+14;
break;
case 3:
outputPrice = outputPrice+18;
break;
default:
break;
}
}
if(!Flag)
{
System.out.println(foodIndish + " does not exist");
}
}
System.out.print(outputPrice);
}
}
题目集三：
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例1:
仅有课程。例如：
java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet
输入样例2:
单门考试课程 单个学生。例如：
java 必修 考试
20201103 张三 java 20 40
end
输出样例2:
在这里给出相应的输出。例如：
20201103 张三 34
java 20 40 34
202011 34
输入样例3:
单门考察课程 单个学生。例如：
java 选修 考察
20201103 张三 java 40
end
输出样例3:
在这里给出相应的输出。例如：
20201103 张三 40
java 40 40
202011 40
输入样例4:
考试课程 单个学生 不匹配的考核方式。例如：
java 必修 考试
20201103 张三 java 20
end
输出样例4:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
java 必修 考察
20201103 张三 java 40
end
输出样例5:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：
java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end
输出样例6:
在这里给出相应的输出。例如：
20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end
输出样例7:
在这里给出相应的输出。例如：
20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：
数据结构 选修 考察
20201103 李四 数据结构 101
end
输出样例8:
在这里给出相应的输出。例如：
wrong format
数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end
输出样例9:
在这里给出相应的输出。例如：
20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72代码如下：
import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.Year;
import java.util.Calendar;
import java.util.Date;
import java.util.InputMismatchException;
import java.util.Scanner;
class Student {
//属性
String sid; //学号
String Name; //姓名
String major; //专业
int age; //年龄
//构造方法
public Student() {
//无参构造方法
}
public Student(String sid, String name, int age, String major) {
this.sid = sid;
this.Name = name;
if (age > 0) {
this.age = age;
} else {
this.age = 0;
}
this.major = major;
}
}
class MyDateW {
private int year;
private int month;
private int day;
public MyDateW(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void setDay(int day) {
if (isValidDay(day)) {
this.day = day;
} else {
System.out.println("日期不合法");
}
}
public boolean isValidDay(int day) {
if (year < 1 || month < 1 || month > 12 || day < 1) {
return false;
}
Calendar cal = Calendar.getInstance();
cal.set(year, month - 1, 1);
int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
return day <= lastDay;
}
}
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String line = input.nextLine();
String nextLine = input.nextLine();
String[] arr = line.split("-");
int year = Integer.parseInt(arr[0]);
int month = Integer.parseInt(arr[1]);
int day = Integer.parseInt(arr[2]);
boolean valid = Main.isValidDate(line, "yyyy-MM-dd");
if (judge(year, month, day) && valid) {
printDateInfo(line);
} else {
System.out.println(line + "无效!");
}
String[] arr1 = nextLine.split(" ");
boolean valid1 = Main.isValidDate(arr1[0], "yyyy-MM-dd");
boolean valid2 = Main.isValidDate(arr1[1], "yyyy-MM-dd");
if (!valid1 || !valid2) {
System.out.println(arr1[0] + "或" + arr1[1] + "中有不合法的日期.");
System.exit(0);
}
DateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
try {
Date startDate = dft.parse(arr1[0]);
Date endDate = dft.parse(arr1[1]);
int[] dateDiff = getDateDiff(startDate, endDate);
if (endDate.before(startDate)) {
System.out.println(arr1[1] + "早于" + arr1[0] + ", 不合法!");
System.exit(0);
}
System.out.println(arr1[1] + "与" + arr1[0] + "之间相差" + dateDiff[0] + "天," +
"所在月份相差" + dateDiff[1] + ",所在年份相差" + dateDiff[2] + ".");
} catch (ParseException e) {
e.printStackTrace();
}
}
public static void printDateInfo(String date) {
Calendar c = Calendar.getInstance();
String[] arr = date.split("-");
int month = Integer.parseInt(arr[1]);
int year = Integer.parseInt(arr[0]);
int day = Integer.parseInt(arr[2]);
c.set(year, month - 1, day);
int weekDay = c.get(Calendar.DAY_OF_WEEK);
int yearDay = c.get(Calendar.DAY_OF_YEAR);
int monthDay = c.get(Calendar.DAY_OF_MONTH);
if (weekDay == 1) {
weekDay = 7;
} else {
weekDay = weekDay - 1;
}
Year firstYear = Year.of(year);
if (firstYear.isLeap()) {
System.out.println(date + "是闰年.");
}
System.out.println(date + "是当年第" + yearDay + "天" +
", 当月第" + monthDay + "天, 当周第" + weekDay + "天.");
}
public static int[] getDateDiff(Date startDate, Date endDate) {
Calendar cal1 = Calendar.getInstance();
cal1.setTime(startDate);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(endDate);
int daysDiff,monthsDiff,yearsDiff;
yearsDiff = 0;
monthsDiff = 0;
daysDiff = 0;
while (cal1.before(cal2)) {
cal1.add(Calendar.DAY_OF_MONTH, 1);
daysDiff++;
if (cal1.get(Calendar.DAY_OF_MONTH) == 1) {
monthsDiff++;
if (cal1.get(Calendar.MONTH) == Calendar.JANUARY) {
yearsDiff++;
}
}
}
return new int[]{daysDiff, monthsDiff, yearsDiff};
}
public static boolean isValidDate(String dttm, String format) {
if (dttm == null || dttm.isEmpty() || format == null || format.isEmpty()) {
return false;
}
if (format.replaceAll("'.+?'", "").indexOf("y") < 0) {
format += "/yyyy";
DateFormat formatter = new SimpleDateFormat("/yyyy");
dttm += formatter.format(new Date());
}
String regex = "^\\d{4}-\\d{2}-\\d{2}$";
if (!dttm.matches(regex)) {
return false;
}
DateFormat formatter = new SimpleDateFormat(format);
formatter.setLenient(false);
ParsePosition pos = new ParsePosition(0);
Date date = formatter.parse(dttm, pos);
if (date == null || pos.getErrorIndex() > 0) {
return false;
}
if (pos.getIndex() != dttm.length()) {
return false;
}
if (formatter.getCalendar().get(Calendar.YEAR) > 9999) {
return false;
}
return true;
}
int Flag = 1;
public static boolean judge(int y, int sum, int date) {
boolean count = false;
if (sum == 1 || sum == 3 || sum == 5 || sum == 7 || sum == 8 || sum == 10 || sum == 12) {
if (date <= 31) {
count = true;
} else {
count = false;
}
} else if (sum < 1 || sum > 12) {
count = false;
} else if (sum == 2) {
if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)) {
if (date > 29) {
count = false;
} else {
count = true;
}
} else {
if (date > 28) {
count = false;
} else {
count = true;
}
}
} else {
if (date > 30) {
count = false;
} else {
count = true;
}
}
return count;
}
}
class MyDate {
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
if (month >= 1 && month <= 12) {
this.month = month;
} else {
System.out.println("月份不合法");
}
}
public int getDay() {
return day;
}
}
class studentGrades {
int dailyGrades; // 平时成绩
int examGrades; // 期末成绩
public studentGrades(int dailyGrades, int examGrades) {
this.dailyGrades = dailyGrades;
this.examGrades = examGrades;
}
public float doubleGrades(){
int doubleGrades = (int) doubleGrades();
Object totalGrades = new Object();
return (float) ((double) totalGrades / 3);
}
public int totalGrades() {
return (int) (dailyGrades * 0.4 + examGrades * 0.6);
}
}
class Flaw {
//属性
String sid; //学号
String Name; //姓名
String major; //专业
int age; //年龄
//构造方法
public Flaw() {
//无参构造方法
}
public Flaw(String sid, String name, int age, String major) {
this.sid = sid;
if (age > 0) {
this.age = age;
} else {
this.age = 0;
}
this.Name = name;
this.major = major;
}
}
class MyDateWWW {
private int year;
private int month;
private int day;
public MyDateWWW(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void setDay(int day) {
if (isValidDay(day)) {
this.day = day;
} else {
System.out.println("日期不合法");
}
}
public boolean isValidDay(int day) {
if (year < 1 || month < 1 || month > 12 || day < 1) {
return false;
}
Calendar cal = Calendar.getInstance();
cal.set(year, month - 1, 1);
int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
return day <= lastDay;
}
}
class MyDateWW {
private int year;
private int month;
private int day;
public MyDateWW(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void setDay(int day) {
if (isValidDay(day)) {
this.day = day;
} else {
System.out.println("日期不合法");
}
}
public boolean isValidDay(int day) {
if (year < 1 || month < 1 || month > 12 || day < 1) {
return false;
}
Calendar cal = Calendar.getInstance();
cal.set(year, month - 1, 1);
int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
return day <= lastDay;
}
}
此题目我没有写出来，水平有待提高，还需继续努力。
从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。
预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。
输入格式:
输入两行，每行输入一个日期，日期格式如：2022-06-18
输出格式:
第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s1 = in.nextLine();
String s2 = in.nextLine();
String [] dataString = s1.split("-");
String [] dataString2 = s2.split("-");
int yearTwo = Integer.parseInt( dataString2[0] );
int yearOne = Integer.parseInt( dataString[0] );
int dayTwo = Integer.parseInt( dataString2[2] );
int monthOne = Integer.parseInt( dataString[1] );
int dayOne = Integer.parseInt( dataString[2] );
int monthTwo = Integer.parseInt( dataString2[1] );
LocalDate date2 = LocalDate.of(yearTwo, monthTwo, dayTwo);
LocalDate date1 = LocalDate.of(yearOne, monthOne, dayOne);
if(date1.isBefore(date2))
{
System.out.println("第一个日期比第二个日期更早");
}
else
{
System.out.println("第一个日期比第二个日期更晚");
}
long dayCount = date1.until(date2, ChronoUnit.DAYS);
long weekCount = date1.until(date2, ChronoUnit.WEEKS);
System.out.println("两个日期间隔" + Math.abs(dayCount) + "天" );
System.out.println("两个日期间隔" + Math.abs(weekCount) + "周" );
}
}
class MyDate {
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void setDay(int day) {
if (isValidDay(day)) {
this.day = day;
} else {
System.out.println("日期不合法");
}
}
public boolean isValidDay(int day) {
if (year < 1 || month < 1 || month > 12 || day < 1) {
return false;
}
Calendar cal = Calendar.getInstance();
cal.set(year, month - 1, 1);
int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
return day <= lastDay;
}
}
心得体会：
此题需要用到日期类来写，通过参考csdn上的有关资料了解了日期类的使用方法，并逐步写出代码。
总结：
在这三次的学习过程中，我学习了日期类的使用方法，学习了类的书写方法，提升了自身的编码水平，以及查资料的能力，但是在面对题目集三的时候还是力不从心，我要从这三次经验教训中学习，在上课时认真听课，下课认真复习，努力提升自己，让Java水平越来越高。