java-blog-1
一、前言
1、知识点：主要是java中一些库函数的调用例如时间函数，动态数组函数，哈希函数等以及正则运算法则的实验
2、题量：题量不大，简单的作业题量多点，难点的作业题量少点总体来说还行
3、难度：难度在不断的变大，每一题所花的时间也在不断的增加
二、设计与分析：
第一次大作业：
输出样例1:
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
代码：
import java.util.Scanner;
import java.lang.Math;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
float a=in.nextFloat();
float b=in.nextFloat();
float c=in.nextFloat();
if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200)
{
if(a+b<=c||a+c<=b||b+c<=a)
System.out.print("Not a triangle");
else if(a==b&&b==c)
System.out.print("Equilateral triangle");
else if(a==b||b==c||a==c)
{
if((a*a+b*b)-c*c<0.1||(a*a+c*c)-b*b<0.1||(c*c+b*b)-a*a<0.1)
System.out.print("Isosceles right-angled triangle");
else
System.out.print("Isosceles triangle");
}
//else if((a==b&&c==Math.sqrt(2)*a)||(a==c&&b==Math.sqrt(2)*a)||(c==b&&a==Math.sqrt(2)*c))
else if(a*a+b*b==c*c||c*c+b*b==a*a||a*a+c*c==b*b)
System.out.print("Right-angled triangle");
else
System.out.print("General triangle");
}
else
System.out.print("Wrong Format");
}
}
总结分析：
整体的框架比较好构建，主要的三角形类型判断的条件需要注意例如等腰直角三角形需要用a*a+b*b-c*c<0.001来判断否则会有精度差就无法正确判断，再者就是else if 嵌套的逻辑结构需要注意点在不同三角形判断中其中某些条件可能是相同的。
第二次大作业：
创建学生类，包含
属性：学号（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
输入样例:
在这里给出一组输入。例如：
22201311 张琳 80 80 80 22201312 黄昊 66 82 81 22201313 李少辰 77 76 80 22201314 袁婷 62 79 90 22201315 朱哲一 74 98 94
输出样例:
在这里给出相应的输出。例如：
22201311 张琳 240 80.00 22201312 黄昊 229 76.33 22201313 李少辰 233 77.67 22201314 袁婷 231 77.00 22201315 朱哲一 266 88.67
代码：
import java.util.Scanner;
public class Main {
private String ID;
private String name;
private int cnscore;
private int mathscore;
private int physcore;
public Main(String ID,String name,int cnscore,int mathscore,int physcore)
{
this.ID=ID;
this.name= name;
this.cnscore=cnscore;
this.mathscore=mathscore;
this.physcore=physcore;
}
public String getID()
{
return ID;
}
public String getname()
{
return name;
}
public int getcnscore()
{
return cnscore;
}
public int getmathscore()
{
return mathscore;
}
public int physcore()
{
return physcore;
}
public int allscore()
{
return (cnscore+mathscore+physcore);
}
public float avgscore()
{
float sum=cnscore+mathscore+physcore;
return (float)(sum/3);
}
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
Main[] stu=new Main[5];
for(int i=0;i<5;i++)
{
String ID= input.next();
String name = input.next();
int cnscore= input.nextInt();
int mathscore =input.nextInt();
int physcore =input.nextInt();
stu[i]=new Main(ID,name,cnscore,mathscore,physcore);
}
for(int j=0;j<5;j++)
{
System.out.println(stu[j].getID()+" "+stu[j].getname()+" "+stu[j].allscore()+" "+String.format("%.2f",stu[j].avgscore()));
}
input.close();
}
}
总结分析：
这里需要注意的是float和double的选择我这是选择了float选double的话可能会产生精度问题对类使用不太熟悉整个框架只用了一个类整体难度偏简单就一个保留两位小数的知识点不知道但题目中也给出了相关的参考资料
创建成绩类，包含：
属性：平时成绩（int）、期末成绩（int）
方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）
创建学生类，包含：
属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）
方法：计算总分、计算平均分
输入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.util.Scanner; class Grades { private int pinshi; private int qimo; public Grades(int pinshi,int qimo) { this.pinshi=pinshi; this.qimo=qimo; } public int getpinshi() { return pinshi; } public int getqimo() { return qimo; } public int totalgrades() { return (int)(pinshi*0.4+qimo*0.6); } } class Student { private String ID; private String name; private Grades cnscore; private Grades mathscore; private Grades physcore; public Student(String ID,String name) { this.ID=ID; this.name= name; } public String getID() { return ID; } public String getname() { return name; } public Grades getMathscore() { return mathscore; } public void setMathscore(Grades mathscore) { this.mathscore = mathscore; } public Grades getPhyscore() { return physcore; } public void setPhyscore(Grades physcore) { this.physcore = physcore; } public Grades getCnscore() { return cnscore; } public void setCnscore(Grades cnscore) { this.cnscore = cnscore; } public int getallscore() { return cnscore.totalgrades()+mathscore.totalgrades()+physcore.totalgrades(); } public double getavgscore() { double sum=cnscore.totalgrades()+mathscore.totalgrades()+physcore.totalgrades(); return (double)(sum/3); } public double getpsavgscore() { double sum=cnscore.getpinshi()+mathscore.getpinshi()+physcore.getpinshi(); return (double)(sum/3); } public double getqmavgscore() { double sum=cnscore.getqimo()+mathscore.getqimo()+physcore.getqimo(); return (double)(sum/3); } } public class Main{ public static void main(String[] args) { Scanner input=new Scanner(System.in); Student[] stu=new Student[3]; Grades[] stu1=new Grades[3]; int a=0; for(int i=0;i<9;i++) { String ID= input.next(); String name = input.next(); String km = input.next(); int pinshi= input.nextInt(); int qimo =input.nextInt(); int j=i%3; if(j==0) { stu[a]=new Student(ID,name); stu[a].setCnscore(new Grades(pinshi,qimo)); } if(j==1) { stu[a].setMathscore(new Grades(pinshi,qimo)); } if(j==2) { stu[a].setPhyscore(new Grades(pinshi,qimo)); a++; } } for(int j=0;j<3;j++) { System.out.println(stu[j].getID()+" "+stu[j].getname()+" " + stu[j].getallscore() + " " + String.format("%.2f %.2f %.2f", stu[j].getpsavgscore(),stu[j].getqmavgscore(),stu[j].getavgscore())); } input.close(); } }
总结分析：
此次题目首次采用封装的程序结构，由于是第一次写又对封装结构不是很懂于是结构写的看起来很像是封装其实不是但在后续的题目中随着对封装的理解加深格式结构也在不断的完善，再者这题还有一个阅题的问题第二个案例给出的三个数据题目中没有给出明确的指示只能自己摸索猜测好在最后摸索出来分别对应的成绩
某饭店提供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 48
代码：
import java.util.*; import java.util.ArrayList; import java.lang.Math; public class Main{ public static void main(String[] args) { Scanner in=new Scanner(System.in); ArrayList<Record> total = new ArrayList<>(); //Record[] total=new Record[3]; Order now=new Order(); Dish[] cai=new Dish[4]; Dish jug; cai[0]=new Dish("西红柿炒蛋",15); cai[1]=new Dish("清炒土豆丝",12); cai[2]=new Dish("麻婆豆腐",12); cai[3]=new Dish("油淋生菜",9); int sum=0; while(true) { String name=in.next(); if(name.equals("end")) break; int portion=in.nextInt(); total.add(now.addARecord(name,portion)); } for (Record total1 : total) { int flag=0; jug=total1.getDish(); // System.out.println(person.getName() + " is " + person.getAge() + " years old."); for(int j=0;j<4;j++) { if(jug.getName().equals(cai[j].getName())) { sum+=cai[j].getPrice(total1.getportion()); flag=1; } } if(flag==0) { System.out.println(jug.getName()+" does not exist"); } } System.out.println(sum); } } class Dish { private String name;//菜品名称 private int unit_price; //单价 //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） public Dish(String name,int unit_price) { this.name=name; this.unit_price=unit_price; } /*public void unit_price(int unit_price ) { this.unit_price=unit_price; }*/ public int getPrice(int portion) { if(portion==1) return (int) unit_price; if(portion==2) return (int) Math.round( unit_price* 1.5); if(portion==3) return (int) unit_price*2; else return 0; } public String getName() { return name; } } //菜谱类：对应菜谱，包含饭店提供的所有菜的信息。 class Menu { private Dish[] dishs ;//菜品数组，保存所有菜品信息 public static Dish findDish(Dish[] dishes,String name)//根据菜名在菜谱中查找菜品信息，返回Dish对象。 { for (Dish dish : dishes) { if (dish.getName().equals(name)) { return dish; } } return null; } public Menu(Dish[] dishs) { this.dishs=dishs; } public Dish[] getdishs() { return dishs; } } //点菜记录类：保存订单上的一道菜品记录 class Record { Dish d;//菜品 Menu menu; int portion;//份额（1/2/3代表小/中/大份） public void setDish(Dish d) { this.d=d; } public Dish getDish( ) { return d; } public void setportion(int portion ) { this.portion=portion; } public int getportion() { return portion; } int getPrice()//计价，计算本条记录的价格 { Dish num=menu.findDish(menu.getdishs(),d.getName()); return num.getPrice(portion); } } //订单类：保存用户点的所有菜的信息。 class Order { Record[] records;//保存订单上每一道的记录 int getTotalPrice()//计算订单的总价 { int sum=0; for(int i=0;i<records.length;i++) { sum+=records[i].getPrice(); } return sum; } Record addARecord(String dishName,int portion) //添加一条菜品信息到订单中。 { Record c=new Record(); c.setDish(new Dish(dishName,0)); c.setportion(portion); return c; } }
总结：
这里是首次运用类的嵌套结构所以这题最大的难点便是逻辑结构的构建以及类之间的调用关系写这题的首要任务便是缕清类与类之间的关系例如oredr类中Record类在存放数据以及调用的时候都需要注意确保数据的准确性我在这里少构建了一个类虽然最后成功运行格式上还是有些瑕疵的。
第三次作业：
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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.util.*; import java.util.Collections; import java.util.regex.Pattern; import java.util.regex.Matcher; import java.util.ArrayList; import java.text.Collator; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); ArrayList<Course> course = new ArrayList<Course>(); // 创建一个空的ArrayList ArrayList<Score> score = new ArrayList<Score>(); ArrayList<Avgscore> avgscore = new ArrayList<Avgscore>(); ArrayList<Bjavg> bjavg = new ArrayList<Bjavg>(); ArrayList<Stavg> stavg = new ArrayList<Stavg>(); try { while( true) { String course2=in.nextLine(); if("end".equals(course2) ) break; Pattern pattern = Pattern.compile("([\\u4e00-\\u9fa5a-zA-Z]{1,10}) (必修|选修) (考试|考察)"); //String score1=in.nextLine(); Pattern pattern1 = Pattern.compile("(\\d{8}) ([\\u4e00-\\u9fa5a-zA-Z]{1,10}) ([\\u4e00-\\u9fa5a-zA-Z]{1,10}) (([0-9]|[0-9][0-9]|100)|(([0-9]|[0-9][0-9]|100) ([0-9]|[0-9][0-9]|100)))"); Matcher matcher = pattern.matcher(course2); Matcher matcher1 = pattern1.matcher(course2); String[] scoreinfom = course2.split(" "); String[] courseinfom = course2.split(" "); if(!matcher.matches()&&!matcher1.matches()) { System.out.println("wrong format"); } boolean falg6=false; if (matcher.matches()) { Course course1= new Course(courseinfom[0],courseinfom[1],courseinfom[2]); for(Course course4:course) { if(course1.getcoursename().equals(course4.getcoursename())) { falg6=true; } } if(falg6==false) course.add(course1); } boolean flag7=false; if(matcher1.matches()) { Integer pinshi; Integer qimo; if(scoreinfom.length==5) { pinshi=Integer.parseInt(scoreinfom[3]); qimo=Integer.parseInt(scoreinfom[4]); Score score2=new Score(scoreinfom[0],scoreinfom[1],scoreinfom[2],pinshi,qimo); for(Score score5:score) { if(score2.getID().equals(score5.getID())&&score2.getcoursename().equals(score5.getcoursename())&&score2.getname().equals(score5.getname())) { flag7=true; } } if(flag7==false) score.add(score2); } if(scoreinfom.length==4) { Integer qimo1=Integer.parseInt(scoreinfom[3]); Integer num=null; Score score2=new Score(scoreinfom[0],scoreinfom[1],scoreinfom[2],num ,qimo1); for(Score score5:score) { if(score2.getID().equals(score5.getID())&&score2.getcoursename().equals(score5.getcoursename())&&score2.getname().equals(score5.getname())) { flag7=true; } } if(flag7==false) score.add(score2); } } } } catch(NumberFormatException e) { System.out.println("wrong format"); } //System.out.println("666"); ArrayList<String> jug2 = new ArrayList<>(); ArrayList<String> jug3 = new ArrayList<>(); for(Score scorejug1 : score) { boolean flag7=false; boolean flag8=false; for(String jug4: jug3) { if(scorejug1.getcoursename().equals(jug4)) { flag8=true; } } if(flag8==false) { if(course.size()==0) { jug3.add(scorejug1.getcoursename()); System.out.println(scorejug1.getcoursename()+"does not exist"); } else { for(Course coursejug1 :course) { if(coursejug1.getcoursename().equals(scorejug1.getcoursename())) { flag7=true; } } if(flag7==false) { jug3.add(scorejug1.getcoursename()); System.out.println(scorejug1.getcoursename()+"does not exist"); } } } } for(Course coursejug :course) { boolean flag=false; Integer pinshiscore=0; Integer qimoscore=0; Integer toscore=0; Integer sum=0; //Integer jugIdscore = null; String jugname = null; if(score.size()==0) { System.out.println(coursejug.getcoursename()+" has no grades yet"); } else { for(Score scorejug : score) { if(coursejug.getcoursename().equals(scorejug.getcoursename())) { flag=true; if("必修".equals(coursejug.getcoursenature())) { if("考试".equals(coursejug.getmethod())) { if(scorejug.getpinshi()==null&&scorejug.getqimo()==null) { } else if(scorejug.getpinshi()==null||scorejug.getqimo()==null) { System.out.println(scorejug.getID() +" " + scorejug.getname() + " : access mode mismatch"); System.out.println(scorejug.getID() +" " + scorejug.getname() + " did not take any exams"); System.out.println(scorejug.getcoursename()+" has no grades yet"); System.out.println(scorejug.getbanji()+" has no grades yet"); } else { int i=(int)(scorejug.getpinshi()*0.3+scorejug.getqimo()*0.7); scorejug.settosorce(i); qimoscore+=scorejug.getqimo(); pinshiscore+=scorejug.getpinshi(); toscore+=scorejug.gettosorce(); sum++; //System.out.println(scorejug.getID() + " " + scorejug.getname()+ " " +scorejug.gettosorce()); // System.out.println(scorejug.getcoursename() + " " + scorejug.getpinshi() + " " + scorejug.getqimo() + " " + scorejug.gettosorce()); //System.out.println(scorejug.getbanji() + " " + scorejug.gettosorce()); } } if("考察".equals(coursejug.getmethod())) { System.out.println(scorejug.getcoursename() + " : course type & access mode mismatch"); System.out.println(scorejug.getcoursename() + " does not exist"); System.out.println(scorejug.getID() +" " + scorejug.getname() + " did not take any exams"); System.out.println(scorejug.getbanji() + " has no grades yet"); } } if("选修".equals(coursejug.getcoursenature())) { if("考试".equals(coursejug.getmethod())) { if(scorejug.getpinshi()==null||scorejug.getqimo()==null) { System.out.println(scorejug.getID() +" " + scorejug.getname() + " : access mode mismatch"); System.out.println(scorejug.getID() +" " + scorejug.getname() + " did not take any exams"); System.out.println(scorejug.getcoursename()+" has no grades yet"); System.out.println(scorejug.getbanji()+" has no grades yet"); } else { int i=(int)(scorejug.getpinshi()*0.3+scorejug.getqimo()*0.7); scorejug.settosorce(i); qimoscore+=scorejug.getqimo(); pinshiscore+=scorejug.getpinshi(); toscore+=scorejug.gettosorce(); sum++; } } if("考察".equals(coursejug.getmethod())) { int i=(int)(scorejug.getqimo()); scorejug.settosorce(i); pinshiscore+=scorejug.getqimo(); toscore+=scorejug.getqimo(); sum++; } } } } } if(flag==true) { if(sum!=0) { Avgscore avgscore1 =new Avgscore(coursejug.getmethod(),coursejug.getcoursename(),pinshiscore,qimoscore,toscore,sum); avgscore.add(avgscore1); jug2.add(coursejug.getcoursename()); } } } Integer num=0; Integer sum1=0; Integer toavg1=0; Integer num1=avgscore.size(); int i=0; boolean flag=false; boolean flag2=false; ArrayList<String> jug = new ArrayList<String>(); ArrayList<String> jug1 = new ArrayList<String>(); ArrayList<String> jugidscore = new ArrayList<String>(); ArrayList<Integer> jugbjscore = new ArrayList<Integer>(); for(Score score1 :score ) { int num3=0; int bjavg1=0; int stavg1=0; int sum11=0; int sum10=0; int num4=0; boolean flag1=false; boolean flag3=false; for(String jug11:jug) { if(score1.getbanji().equals(jug11)) { flag1=true; } } for(String jug12:jug1) { if(score1.getID().equals(jug12)) { flag3=true; } } if(flag3==false) { jugidscore.add(score1.getID()); } for(Score score2 :score) { if(flag3==false) { if(score1.getID().equals(score2.getID())) { if(score2.gettosorce()!=null) { sum10++; num4+=score2.gettosorce(); flag2=true; jug1.add(score1.getID()); } } } if(flag1==false) { if(score1.getbanji().equals(score2.getbanji())) { if(score2.gettosorce()!=null) { sum11++; num3+=score2.gettosorce(); flag=true; jug.add(score1.getbanji()); } } } } if( flag==true) { if(sum11!=0) { bjavg1=(int)(num3/sum11); Bjavg bjavg2=new Bjavg(score1.getbanji(),bjavg1); bjavg.add(bjavg2); jugbjscore.add(bjavg1); } } if( flag2==true) { if(sum10!=0) { stavg1=(int)(num4/sum10); Stavg stavg2=new Stavg(score1.getID(),score1.getname(),stavg1); stavg.add(stavg2); } } } String[] coursesArray1 = jugidscore.toArray(new String[0]); Arrays.sort(coursesArray1); for(String jugidscore1: coursesArray1) { for(Stavg stavg3: stavg) { if((stavg3.getid()).equals(jugidscore1)) { System.out.println(stavg3.getid()+ " " + stavg3.getname() + " " + stavg3.getstavg()); } } } String[] coursesArray = jug2.toArray(new String[0]); Collator collator = Collator.getInstance(java.util.Locale.CHINA); Arrays.sort(coursesArray,collator); for (String course2 : coursesArray) { for(Avgscore avgscore1 :avgscore ) { if(avgscore1.getcoursename().equals(course2)) { if(avgscore1.getcoursemethod().equals("考察")) System.out.println(avgscore1.getcoursename() + " " + avgscore1.getpinshiavg() + " " +avgscore1.gettoavg()); if(avgscore1.getcoursemethod().equals("考试")) System.out.println(avgscore1.getcoursename() + " " + avgscore1.getpinshiavg() + " " +avgscore1.getqimoavg()+ " " +avgscore1.gettoavg()); } } } Integer[] coursesArray0 = jugbjscore.toArray(new Integer[0]); Arrays.sort(coursesArray0, Collections.reverseOrder()); for(Integer bjscore:coursesArray0 ) { for(Bjavg banscore: bjavg) { if(banscore.getbanavg().equals(bjscore)) { System.out.println(banscore.getbanji()+ " " + banscore.getbanavg()); } } } } } class Course{ private String coursename; private String coursenature; private String method; public Course (String coursename,String coursenature,String method){ this.coursename=coursename; this.coursenature=coursenature; this.method=method; } public void setcoursename() { this.coursename=coursename; } public void setcoursenature() { this.coursenature=coursenature; } public void setmethod() { this.method=method; } public String getcoursename() { return coursename; } public String getcoursenature() { return coursenature; } public String getmethod() { return method; } } class Score { private String name; private String ID; private String coursename; private String banji; private Integer pinshi; private Integer qimo; private Integer tosorce; public Score(String ID,String name,String coursename,Integer pinshi,Integer qimo) { this.name=name; this.ID=ID; this.coursename=coursename; this.pinshi=pinshi; this.qimo=qimo; } public String getname() { return name; } public void settosorce(Integer tosorce) { this.tosorce=tosorce; } public String getID() { return ID; } public String getbanji() { banji=ID.substring(0,6); return banji; } public Integer getpinshi() { return pinshi; } public Integer getqimo() { return qimo; } public String getcoursename() { return coursename; } public Integer gettosorce() { return tosorce; } } class Avgscore //implements Comparable<Avgscore> { private Integer pinshiavg; private Integer qimoavg; private Integer toavg; private Integer sum; private String coursename; private String coursemethod; public Avgscore(String coursemethod,String coursename,Integer pinshiavg,Integer qimoavg,Integer toavg,Integer sum) { this.coursename=coursename; this.pinshiavg=pinshiavg; this.qimoavg=qimoavg; this.toavg=toavg; this.coursemethod=coursemethod; this.sum=sum; } public int getpinshiavg() { return (int)(pinshiavg/sum); } public int getqimoavg() { return (int)(qimoavg/sum); } public int gettoavg() { return (int)(toavg/sum); } public String getcoursename() { return coursename; } public String getcoursemethod() { return coursemethod; } /*@Override public int compareTo(Avgscore other) { return this.coursename.compareTo(other.getcoursename()); } */ } class Bjavg { private String banji; private Integer banavg; public Bjavg(String banji,Integer banavg) { this.banavg=banavg; this.banji=banji; } public String getbanji() { return banji; } public Integer getbanavg() { return banavg; } } class Stavg { private String name; private String ID; private Integer stavg; public Stavg(String ID,String name,Integer stavg) { this.name=name; this.stavg=stavg; this.ID=ID; } public String getname() { return name; } public String getid() { return ID; } public Integer getstavg() { return stavg; } }
总结：
此次题目并没有过全部的测试点因为这次的题目难度与之前的不同明显感觉难了第一个问题便是正则表达式的正确运用需要揣摩正确的输入格式并使用相应的正则表达式第二个问题便是算法中循环结构比较多并且循环结构中所处理的数据多而杂所以尤其需要注意逻辑结构的嵌套需要理清整体先构建什么在构建什么以及先判定哪些条件第三个问题便是数据的存储与调用输入的数据需要存到相应的类中数据类型比较多样有班级平均成绩有课程平均成绩有个人成绩而且有些数据需要经过相应的处理例如求平均成绩都需要与逻辑结构一起考虑输入的数据理清楚并存储在相应的类中后来的数据调用相对来所说会简单一些。
从键盘输入两个日期，格式如：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周
输入样例1:
2000-02-18 2000-03-15
输出样例1:
第一个日期比第二个日期更早 两个日期间隔26天 两个日期间隔3周
输入样例2:
2022-6-18 2022-6-1
输出样例2:
第一个日期比第二个日期更晚 两个日期间隔17天 两个日期间隔2周
代码：
import java.time.LocalDate; import java.time.temporal.ChronoUnit; import java.util.*; import java.text.SimpleDateFormat; import java.util.Date; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd"); // 定义不规则日期 String date1Str = scanner.nextLine(); String date2Str = scanner.nextLine(); try { Date date1 = inputFormat.parse(date1Str); Date date2 = inputFormat.parse(date2Str); SimpleDateFormat outputFormat1 = new SimpleDateFormat("yyyy-MM-dd"); String outputDate1 = outputFormat1.format(date1); String outputDate2 = outputFormat1.format(date2); LocalDate dateone = LocalDate.parse(outputDate1); LocalDate datetwo = LocalDate.parse(outputDate2); long daysBetween = Math.abs(ChronoUnit.DAYS.between(dateone, datetwo)); long weeksBetween = Math.abs(ChronoUnit.WEEKS.between(dateone, datetwo)); if (dateone.isBefore(datetwo)) { System.out.println("第一个日期比第二个日期更早"); } if( dateone.isAfter(datetwo) ) { System.out.println("第一个日期比第二个日期更晚"); } System.out.println("两个日期间隔" + daysBetween + "天"); System.out.println("两个日期间隔" + weeksBetween + "周"); } catch (Exception e) { e.printStackTrace(); } } }
总结：
这题主要考察格式问题和库函数的调用在写这题之前因为并未了解正则表达式所以就只运用了库函数来对日期格式进行强制转换但感觉这题用正则表达式的话会好一点因为输入是不规则的例如月份可能是一位数也可能是两位数在查阅资料的时候先查到format函数于是便用了format函数。
三、踩坑心得
1.对基础语法的不熟悉例如正则表达式动态数组的构建
2.对库函数的不熟悉用库函数之前并为完全了解库函数的用法导致用起来总是出错
3.传参的时候变量对应没注意容易出错
4.没有使用debug的习惯让找问题变的困难
四、主要困难和改进意见
1.多使用debug调试来找问题
2.多学习java中的库函数在java中有许多可以之间用的库函数这样就可以节省不少时间用来写算法当然库函数的使用多找点相似案列学习下再使用会事半功倍
3.写类比较多的题时先缕清大致框架再去写比较细的东西框架没构建好的话后面遇到问题很难解决即使解决了结构也变了不是每遇到问题都到大变的话代码肯定是有问题的
五、总结
1.代码不能想到哪写到哪需要先构思
2.写代码的习惯有些问题需要后续改进
3.深入了解到java中面对对象编程的含义
浙公网安备 33010602011771号