一.前言
第三次写Blog，相比较上一次而言自己的经验更加的丰富了，这次blog的书写相对来说要更为轻松些。内容上题目较少，只需要分析有关课程成绩统计系统，但是说容易也并不容易，每一道题都是刺头中的刺头，这一次写博客，不仅仅是以完成任务的目的，更多的，让自己重新对那些打击过自己，折磨过自己的题目进行一次整体性的回顾。对于这次博客，我把它当作对自己过去几星期在JAVA里旅途的回望，对我付出无数心血的pta大作业的再一次审视，对我这段时间学习的一次总结。
期中后第一次大作业
1.课程成绩统计程序-1
题目只有一道题，题目难度适中。
期中后第一次大作业主要考察点：
（1）：考察做题人对题目的理解程度和分析程度是否到位。这一次新的大作业系列课程成绩统计程序的开启，从一个新的角度去考察学生对题意的了解分析能力。一个题目中包含了很多的要求，这就需要做题人有清晰的头脑和思想去读题，去分析题目所给的条件和问题。这次大作业中，混合着很多的排序，这些不同排序的不同处理判断对于代码的结构是一次重大的考验，如果你的代码结构不清晰不完整，很有可能被其中一种错误判断钻了空子导致测试点过不去，而且这种逻辑错误很难发现。比如题目中所要求的课程排序，在中英文混合的情况之下，很多的排序算法都不适用，无法排序成功，导致题目出错。
（2）：考察做题人对于较高难度题目是否能从多方面进行思考的能力，能否从更全面的方向考虑问题的能力。这次题目中所出现的对错误信息的处理，在输出时的不同的情况要输出不同的方式，将几种错误排列组合起来，会发现要考虑的东西确实有非常多种情况。在如输入的成绩超出范围时，就不录入学生，而当学生输入的成绩所带课程不匹配，又将学生录入等等情况。
（3）：考察做题人对题目要求的简化能力以及对多变量关系的处理能力。这次课程成绩统计系统，为了更好的迎合题目需求，我们大多采用了如hashmap，hashset，arraylist等方法去存入课程，学生等信息，便于后面进行排序，输出等操作。运用这些方法能够在满足我们需要的同时一定程度上简化我们的代码，与此同时，随着多种判断的出现，不可避免的要增加一些语句和变量去适应这些判断，这对于多变量的处理也有一定的考验。
期中后第二次大作业
按要求只分析课程成绩统计程序2
2.课程成绩统计程序-2
题目只有一道题，题目难度较难。
期中后第二次大作业主要考察点：
（1）：旨在考察做题人对于数据计算（如四舍五入，取整数）的准确把握能力。这次课程成绩统计程序新加入了实验课程，而实验课程成绩的计算需要将所有成绩加起来再除以实验次数，这就在代码计算处理上增加了一定的难度。如果在计算时四舍五入不规范，就会导致计算出现1的偏差甚至更多。这对于做题人在计算与舍入的顺序上要进行一定的思考和测试。在整数与浮点数的转换和把握上要下功夫去思考。
（2）：旨在考察做题人对于题目的读题能力，考察做题人能否理解题意，按照题目要求来进行代码编写和功能实现。在这次大作业中新加入的实验课程，在课程输入输出上又增加了很多的限制和情况，这对做题人对于题目的读题能力，考察做题人能否理解题意有一定程度上的考察，当实验课程与其他课程混合起来，情况就会变的复杂多样化。
（3）：旨在考察做题人对条件判断语句的编写能力，以及对类的合理创建。大作业对于输入语句的是否合理需要有语句去判断，其中用的比较多而实用性强的是正则表达式，而正则表达式的上手门槛不低，需要去仔细研究。同时，新的大作业对于类的需求也发生改变，我们可以通过自行的思考，创建一些新的类使我们更加方便的解题，如对实验课程采取继承，对数据创建类去进行整体性收集，对计算部分创建类去综合起来等等。
期中后第三次大作业
按要求只分析课程成绩统计程序3
2.课程成绩统计程序-3
题目只有一道题，题目难度较难。
期中后第三次大作业主要考察点：
（1）：旨在考察学生对类结构的转换设计能力，测试学生是否能自如的转换代码结构达到相应功能。按题目要求，本次作业修改类的结构，将成绩类继承关系改为了组合，考察学生是否能够适应这种变化，并相应的做出改变。
（2）：旨在考察做题人对于数据计算的处理能力。这次大作业新增了自添加权重这一概念，导致在计算成绩时会遇到四舍五入等计算的方法，每一个小成绩需要乘上相应的权重再进行相加得出相应的总成绩。如果在计算的过程中没有处理好四舍五入的位置，就会导致计算出现相应的错误。
（3）：旨在考察做题人对于不同错误语句的处理能力，对多种错误情况的输出处理能力。在加入了权重之后，课程录入的输入语句和相应的成绩录入输入语句都发生了一定程度的改变，这就增加了很多错误输入的情况，需要做题人自己去分析和测试不同错误输入的情况所应该输出的语句。比如当我们录入了一个实验课程，而成绩录入时录入了一个对应该实验课程的必修成绩样例，这就需要我们在录入学生和班级的同时输出不匹配课程和成绩不存在的相应的错误输出语句。
二. 设计与分析
期中后第一次大作业：
这次大作业难度较大，需要进行深入分析。
下面是我这次课程成绩统计程序1的类图：
Main类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为3，Branches为0，calls为0，Comments为9.1，class为1，Method为1，Lines为11。
Play类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为160，Branches为41.9，calls为141，Comments为5.8，class为2，Method为2，Lines为224。
Student类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为34，Branches为23.5，calls为10，Comments为0.0，class为1，Method为3，Lines为44。
StudentClass类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为5，Branches为0.0，calls为0，Comments为0.0，class为1，Method为0，Lines为6。
KeCheng类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为11，Branches为0.0，calls为0，Comments为0.0，class为1，Method为3，Lines为12。
BanJi类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为11，Branches为9.1，calls为1，Comments为0.0，class为1，Method为1，Lines为15。
Judge类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为28，Branches为3.6，calls为10，Comments为16.3，class为1，Method为10，Lines为43。
主方法上：我这次将主要的运行代码放在了新建的Play类中，所以我的main方法只有一个Play的运行方法。在Play中，我创建了String类型的s去接收输入的每一行信息。
创建Juage类在while循环中配合if else等判断语句实现判断的功能，在该程序中，我运用了ArrayList去存储BanJi和Student的数据，运用ArrayList方便进行存储和使用。对KeCheng我使用了HashMap类型，用课程名为Key进行存储，通过课程的名字去访问需要的课程。while语句用来执行整个输入程序。
在主要结构上，我采取一个while循环来进行功能的实现。while循环用来处理整个输入。将该while语句与Juage类中的正则表达式进行联合，如果接收到end就退出while循环进入输出阶段，如果符合相应的Juage方法就进入相应的输入处理程序当中。有符合必修的，选修的Juage正则表达式判断。
在输出的方面，我运用了几个for循环去实现对班级，学生和课程成绩的输出，在输出前运用了list等方法去进行排序，通过list配合key实现正常排序输出。通过新建的list收集kecheng的key，通过key来实现排序输出。
Juage类中，我编写了很多种情况的正则判断方法，用来判断输入的信息是必修课程还是选修课程等情况。通过Juage我能够很清晰的处理每一个输入的信息。
StudentClass类中，我写入了String 类型的Kecheng用来存入成绩录入信息中相关的课程名，创建int类型的totalChengJi, pingShiChengJi ,qiMoChengJi用来分别存入成绩输入的总成绩，平时成绩和期末成绩。
KeCheng类中，我写入了String 类型的name，xingzi和kaoshifangshi用来存入课程录入时存入的课程名，课程性质，课程的考试方式。设置了布尔类型的pingshi1和qimo1，total1以及shuchu用来分别判断该课程是否有平时成绩，期末成绩，总成绩和是否输出。有一个set方法方便存入数据。
BanJi类中，我设置了String类型的name存入班级号。创建ArrayList类型的Student存入符合该班级的每一个学生，并用int类型的studentShu另外记录学生数，int类型的zongchengji记录该班级的成绩。用int类型的ZhongChengJi方法来判断该班级是否有成绩。
Student类中，我创建了String类型的name和number来存入学生的姓名和学号，用int类型的totalChengJi来存入总成绩，创建StudentClass来存入每一个学生的所有的课程成绩，有一个set方便数据存入，setStudentClass来存入同一个学生的学科。
期中后第二次大作业：
这次大作业难度较大，需要进行深入分析。
下面是我这次课程成绩统计程序2的类图：
BanJi类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为11，Branches为9.1，calls为1，Comments为0.0，class为1，Method为1，Lines为15。
KeCheng类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为11，Branches为0.0，calls为0，Comments为0.0，class为1，Method为3，Lines为12。
StudentClass类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为5，Branches为0.0，calls为0，Comments为0.0，class为1，Method为0，Lines为6。
Judge类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为28，Branches为3.6，calls为10，Comments为16.3，class为1，Method为10，Lines为43。
Main类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为3，Branches为0，calls为0，Comments为9.1，class为1，Method为1，Lines为11。
Play类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为217，Branches为43.3，calls为191，Comments为5.9，class为2，Method为2，Lines为303。
Student类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为40，Branches为25，calls为11，Comments为0，class为1，Method为3，Lines为52。
主方法上：我这次将主要的运行代码放在了新建的Play类中，所以我的main方法只有一个Play的运行方法。在Play中，我创建了String类型的s去接收输入的每一行信息。
创建Juage类在while循环中配合if else等判断语句实现判断的功能，在该程序中，我运用了ArrayList去存储BanJi和Student的数据，运用ArrayList方便进行存储和使用。对KeCheng我使用了HashMap类型，用课程名为Key进行存储，通过课程的名字去访问需要的课程。while语句用来执行整个输入程序。
在主要结构上，我采取一个while循环来进行功能的实现。while循环用来处理整个输入。将该while语句与Juage类中的正则表达式进行联合，如果接收到end就退出while循环进入输出阶段，如果符合相应的Juage方法就进入相应的输入处理程序当中。有符合必修的，选修的Juage正则表达式判断。相比上一次的课程成绩程序，这次我增加了新的判断方法和新的符合实验的录入课程代码和实验课程成绩处理，在原来的基础上适应新的功能，新的要求。
在输出的方面，改动与上一次相比无什么大的差异，输出的方面，我运用了几个for循环去实现对班级，学生和课程成绩的输出，在输出前运用了list等方法去进行排序，通过list配合key实现正常排序输出。通过新建的list收集kecheng的key，通过key来实现排序输出。在原来的基础上我修改了对于成绩不存在的判断，适应新出现的实验成绩。
Juage类中，我新增加了对实验课程的判断，包括对实验课程的录入语句判断和实验课程有关的成绩信息的录入判断。 Juage类中，我编写了很多种情况的正则判断方法，用来判断输入的信息是必修课程还是选修课程等情况。通过Juage我能够很清晰的处理每一个输入的信息。
BanJi类中，我设置了String类型的name存入班级号。创建ArrayList类型的Student存入符合该班级的每一个学生，并用int类型的studentShu另外记录学生数，int类型的zongchengji记录该班级的成绩。用int类型的ZhongChengJi方法来判断该班级是否有成绩。
StudentClass类中，我写入了String 类型的Kecheng用来存入成绩录入信息中相关的课程名，创建int类型的totalChengJi, pingShiChengJi ,qiMoChengJi用来分别存入成绩输入的总成绩，平时成绩和期末成绩。
KeCheng类中，我写入了String 类型的name，xingzi和kaoshifangshi用来存入课程录入时存入的课程名，课程性质，课程的考试方式。设置了布尔类型的pingshi1和qimo1，total1以及shuchu用来分别判断该课程是否有平时成绩，期末成绩，总成绩和是否输出。有一个set方法方便存入数据。
Student类中，我创建了String类型的name和number来存入学生的姓名和学号，用int类型的totalChengJi来存入总成绩，创建StudentClass来存入每一个学生的所有的课程成绩，有一个set方便数据存入，setStudentClass来存入同一个学生的学科。这次我新加了int类型的zhongchengji方法来计算学生的总成绩。
期中后第三次大作业：
这次大作业难度较大，需要进行深入分析。
下面是我这次课程成绩统计程序3的类图：
BanJi类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为11，Branches为9.1，calls为1，Comments为0，class为1，Method为3，Lines为15。
Juage类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为28，Branches为3.6，calls为10，Comments为16.3，class为1，Method为10，Lines为43。
KeCheng类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为13，Branches为0.0，calls为1，Comments为0.0，class为1，Method为3，Lines为14。
Main类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为3，Branches为0，calls为0，Comments为9.1，class为1，Method为1，Lines为11。
StudentClass类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为5，Branches为0.0，calls为0，Comments为0.0，class为1，Method为0，Lines为6。
Play类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为243，Branches为43.6，calls为216，Comments为5.6，class为2，Method为2，Lines为339。
Student类的SourceMonitor的生成报表内容：
通过图片我们可以看出Statements为40，Branches为25，calls为13，Comments为0，class为1，Method为3，Lines为52。
主方法上：大概的内容与前一次没有太大的差别，差别在于我修改了if语句的判断条件和各if语句中的处理语句，由于权重的出现，juage类和相应的各种处理语句都需要做出相应的修改，包括如同实验成绩的数量处理，读取处理和计算处理等等。用for循环检查每一次的成绩是否在符合范围之内。
通过将输入语句中的权重信息相加起来进行收集，用float让相加更加准确，设置多个if语句来逐层的判断错误信息，在判断权重时改为使用一个两位数范围而不是直接与1进行相比来适配float型。
Juage类中，因为输入数据的长度不可控，我选择使用简单的.*的处理方式去进行数据后部分的处理，通过前面最基础的判断方式去接收在基础信息上正确的数据，然后在后续对数据的深入判断的过程中对输入的数据进行二次判断，即在不改变原先判断正则的基础上，暂时性的忽略后面的数据，在接收后再二次处理。
BanJi类中，与上次的程序一致，因为程序适配我并未做任何修改。我设置了String类型的name存入班级号。创建ArrayList类型的Student存入符合该班级的每一个学生，并用int类型的studentShu另外记录学生数，int类型的zongchengji记录该班级的成绩。用int类型的ZhongChengJi方法来判断该班级是否有成绩。
StudentClass类中，与上一次的程序一致，我写入了String 类型的Kecheng用来存入成绩录入信息中相关的课程名，创建int类型的totalChengJi, pingShiChengJi ,qiMoChengJi用来分别存入成绩输入的总成绩，平时成绩和期末成绩。
KeCheng类中，我在原先的基础上增加了新的属性，ArrayList<Float> FloatArrayList ，用来存入课程录入时适配于课程的权重，方便在后续计算总成绩进行计算。
Student类中，我的代码与上一次作业的代码大致相同，我创建了String类型的name和number来存入学生的姓名和学号，用int类型的totalChengJi来存入总成绩，创建StudentClass来存入每一个学生的所有的课程成绩，有一个set方便数据存入，setStudentClass来存入同一个学生的学科，创建int类型的zhongchengji方法来计算学生的总成绩。
三.踩坑心得
期中后第一次大作业：
课程成绩统计系统1中出现的错误点：
错误点1：在重复的课程信息出现的时候没有完整的处理该课程信息，本来按照题目的要求应该舍去相同的输入的课程或成绩信息，但是我没有做相应的处理，导致有测试点出错。将判断重复数据则忽略的代码忽略后得到正确结果。
修改后：
这次错误让我了解到对于读题应该仔细仔细再仔细，题目中给过的提示和条件都应该被实现在第一次的代码当中。
错误点2：在编写课程成绩统计程序的过程中，我遗忘了班级的排序，没有将班级的顺序按照成绩排序输出，导致出错。将班级的排序按照成绩的大小排序后输出正确结果。
修改后：
这次错误让我了解到在提交代码之前应该先验证自己程序的完整性，不应该盲目的提交而忽略部分功能，要保证自己题目代码能够基本符合题目的主体要求。
错误点3：在编写该程序的过程中，我原先是将成绩是否具有的判断设定为如果成绩总值为0，则输入的该学生的成绩或该课程或该班级的成绩就作废，输出没有成绩。但是我忽略了如果本身学生或班级或课程的成绩就是零的情况发生。如果输入的成绩合理且为零，那原本应该正常输出的学生成绩就输出了无成绩的情况发生。而case 10就是考察做题人是否考虑了成绩为零的这种情况的出现。将判断条件从单纯的等于零改为增加判断变量后得到正确结果。
修改后：
错误点4：为了实现课程的正确顺序的输出，我编写了treemap类型的按照字母排序的方式，但是经过不断的测试我发现当输入的课程是有中文有英文的时候使用treemap没有办法将中英文混合的课程信息实现正确的排序，因为这其中混入了关于字典的排序，所以很有几个测试点没有办法过。经过我的查阅，我使用了适配kecheng中的key课程名的String类型的list来二次存入课程名称，并使用Collection的sort排序方法配合着list和改写的排序方法进行中英文混合排序，通过for循环利用list适配hashmap课程中相同课程名的课程。实现排序输出。
修改后：
错误点5：在计算学生总成绩时，我将错误的学生信息都去除了，导致在后面计算班级的总成绩时，我的程序的分母会和标准答案出现偏差，导致计算出来的总成绩出现错误。经过修改存储学生个数的判定条件和存入方式后，得到正确答案。
修改后：
主体原码如下：
class Play{//主体运行界面
public void startIt(){
Scanner input = new Scanner(System.in);
String s = input.nextLine();
Juage juage = new Juage();//创建判断类
ArrayList<Student>students = new ArrayList<>();
ArrayList<BanJi> banJis = new ArrayList<>();
HashMap<String,KeCheng> keChengs = new HashMap<>();//创建课程的数组
while(true){
String[] arrs = s.split(" ");//分割
if(s.equals("end")){//退出
break;
}
else if(juage.JuageBiXiuClassInput2(s)){
System.out.println(arrs[0]+" "+": "+"course type & access mode mismatch");
}
else if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)||juage.JuageXuanXiuClassInput(s)){//必修课程和选修课程
if(juage.JuageKeChengName(arrs[0])){//课程超长名字
System.out.println("wrong format");
}
else if(!keChengs.containsKey(arrs[0])){
KeCheng keCheng = new KeCheng();
if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)){
if(juage.JuageBiXiuClassInput(s)){
keCheng.set(arrs[0],arrs[1],"考试");
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
}
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
}
keChengs.put(arrs[0],keCheng);//存入数组
}
}
else if(juage.JuageStudentPingShi(s)) {//学生信息含平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考察")){
boolean has = false;
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]));
}
}
if(!getin){
student.setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]));
students.add(student);
}
}
}else if(juage.JuageStudentNoPingShi(s)){//无平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考试")){
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]));
}
}
if(!getin){
student.setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]));
students.add(student);
}
}
}
else{//错误输入
System.out.println("wrong format");
}
s = input.nextLine();//再次输入
}
ArrayList<String> studentNumber = new ArrayList<>();
for(int i=0;i<students.size();i++){
studentNumber.add(students.get(i).number);
}
studentNumber.sort(Comparator.naturalOrder());
for(int i=0;i<studentNumber.size();i++){
for(int j=0;j<students.size();j++){
if(studentNumber.get(i).equals(students.get(j).number)){
if(students.get(j).ZhongChengJi()==-1){
System.out.println(students.get(j).number+" "+students.get(j).name+" "+"did not take any exams");
}else{
System.out.println(students.get(j).number+" "+students.get(j).name+" "+students.get(j).ZhongChengJi());
}
}
}
}
List<String> list = keChengs.keySet().stream().collect(Collectors.toList());
Collections.sort(list,new paixu());
for(String key:list){
KeCheng keCheng = keChengs.get(key);
int total = 0;int qimo = 0;int pingshi = 0;int studentShu = 0;
for(int j=0;j<students.size();j++){
for(int k=0;k<students.get(j).studentClasses.size();k++){
if(students.get(j).studentClasses.get(k).kecheng.equals(keCheng.name)){
studentShu++;
if(students.get(j).studentClasses.get(k).totalChengJi!=-1){
keCheng.total1 = true;
total = total + students.get(j).studentClasses.get(k).totalChengJi;
}
if(students.get(j).studentClasses.get(k).pingShiChengJi!=-1){
keCheng.pingshi1 = true;
pingshi = pingshi + students.get(j).studentClasses.get(k).pingShiChengJi;
}
if(students.get(j).studentClasses.get(k).qiMoChengJi!=-1){
keCheng.qimo1 = true;
qimo = qimo + students.get(j).studentClasses.get(k).qiMoChengJi;
}
}
}
}
if(keCheng.kaoShiFangShi.equals("考试")){
if(keCheng.qimo1&& keCheng.pingshi1&&keCheng.total1){
System.out.println(keCheng.name+" "+pingshi/studentShu+" "+qimo/studentShu+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}else{
if(keCheng.qimo1&&keCheng.total1){
System.out.println(keCheng.name+" "+qimo/studentShu+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}
}
for(int i=0;i<students.size();i++){
boolean has = false;
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(students.get(i).number.substring(0,6))){
banJis.get(j).studentShu++;
has = true;
if(students.get(i).ZhongChengJi()!=-1){
banJis.get(j).ZongHe = true;
banJis.get(j).zongChengJi = banJis.get(j).zongChengJi + students.get(i).ZhongChengJi();
}
}
}
if(!has){
BanJi banJi = new BanJi();
banJi.name = students.get(i).number.substring(0,6);
banJi.studentShu++;
if(students.get(i).ZhongChengJi()!=-1){
banJi.ZongHe = true;
banJi.zongChengJi = banJi.zongChengJi + students.get(i).ZhongChengJi();
}
banJis.add(banJi);
}
}
ArrayList<String> banjiString = new ArrayList<>();
for(int i=0;i<banJis.size();i++){
banjiString.add(banJis.get(i).name);
}
banjiString.sort(Comparator.naturalOrder());
for(int i=0;i<banjiString.size();i++){
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(banjiString.get(i))){
if(!banJis.get(j).ZongHe){
System.out.println(banJis.get(j).name+" has no grades yet");
}else{
System.out.println(banJis.get(j).name+" "+banJis.get(j).ZhongChengJi());
}
}
}
}
}
static class paixu implements Comparator<String>{
public int compare(String o,String o1) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(o,o1);
}
}
}
期中后第二次大作业：
课程成绩统计系统2中的错误点：
错误点1，2：我在编写程序的过程中，错将样例看错，本来是成绩超过100应该输出wrong format的输出信息，但是我却输出了课程不存在的情况，误会了样例的题意。同时，我误会了题目的意识，以为班级的输出要按班级的班级号来按顺序排序输出，导致自己出现了很多的错误。将对不在合理范围内的成绩语句输出wrong format，同时修改对班级成绩输出的排序。
修改后：
错误点3：经过多次的检查和测试，我发现自己的学生成绩的输出与样例中的学生输出不一致，样例中的学生输出只会输出一个数据，而不会出现课程成绩统计系统1中的平时成绩的情况发生。经过一顿对比，我发现按要求只需要输出学生的总成绩就可以，不需要输出其他的成绩。将成绩输出修改后，输出了正确的结果。
修改后：
错误点4：经过一定的检查之后，我发现自己在处理课程不匹配的成绩信息的时候，我会将提及到的学生录入到最后总成绩的计算中，这就导致我的班级和课程的计算出现了错误，而如果不录入该学生则无法输出相应的错误输出语句，经过不断的测试，我在计算总成绩的程序中加入了单独的处理语句。经过修改后得到正确答案。
修改后：
主体代码如下：
class Play{//主体运行界面
public void startIt(){
Scanner input = new Scanner(System.in);
String s = input.nextLine();
Juage juage = new Juage();//创建判断类
ArrayList<Student>students = new ArrayList<>();
ArrayList<BanJi> banJis = new ArrayList<>();
HashMap<String,KeCheng> keChengs = new HashMap<>();//创建课程的数组
while(true){
String[] arrs = s.split(" ");//分割
if(s.equals("end")){//退出
break;
}
else if(juage.JuageBiXiuClassInput2(s)||juage.JuageXuanXiuClassInput2(s)){
System.out.println(arrs[0]+" "+": "+"course type & access mode mismatch");
}
else if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)||juage.JuageXuanXiuClassInput(s)){//必修课程和选修课程
if(juage.JuageKeChengName(arrs[0])){//课程超长名字
System.out.println("wrong format");
}
else if(!keChengs.containsKey(arrs[0])){
KeCheng keCheng = new KeCheng();
if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)){
if(juage.JuageBiXiuClassInput(s)){
keCheng.set(arrs[0],arrs[1],"考试");
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
}
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
}
keChengs.put(arrs[0],keCheng);//存入数组
}
}else if(juage.JuageShiYanclassInput(s)){//实验
if(juage.JuageKeChengName(arrs[0])){//课程超长名字
System.out.println("wrong format");
}else if(!juage.JuageShiYanclassInput2(s)){
System.out.println(arrs[0]+" "+": "+"course type & access mode mismatch");
}else if(!keChengs.containsKey(arrs[0])){
KeCheng keCheng = new KeCheng();
keCheng.set(arrs[0],arrs[1],arrs[2]);
keChengs.put(arrs[0],keCheng);//存入数组
}
}
else if(juage.JuageStudentPingShi(s)) {//学生信息含平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考察")){
boolean has = false;
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]));
}
}
if(!getin){
student.setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]));
students.add(student);
}
}
}else if(juage.JuageStudentNoPingShi(s)){//无平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考试")){
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]));
}
}
if(!getin){
student.setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]));
students.add(student);
}
}
}
else if(arrs.length>4&&Integer.valueOf(arrs[3])>=4&&Integer.valueOf(arrs[3])<=9){//实验
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
boolean getin2 = true;
if(arrs.length>4&&(arrs.length-4==Integer.valueOf(arrs[3]))&&Integer.valueOf(arrs[3])>=4){
for(int i=4;i<arrs.length;i++){
if(Integer.valueOf(arrs[i])<0||Integer.valueOf(arrs[i])>100){
System.out.println("wrong format");
getin2 = false;
break;
}
}
}
if(getin2){
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(!keCheng.kaoShiFangShi.equals("实验")||arrs.length!=(Integer.valueOf(arrs[3])+4)){
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}
else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]));
}
}
if(!getin){
int grade = 0;
for(int i=4;i<arrs.length;i++){
grade = Integer.valueOf(arrs[i]) + grade;
}
student.setStudentClasses(arrs[2],-1, grade/Integer.valueOf(arrs[3]));
students.add(student);
}
}
}
}
else{//错误输入
System.out.println("wrong format");
}
s = input.nextLine();//再次输入
}
ArrayList<String> studentNumber = new ArrayList<>();
for(int i=0;i<students.size();i++){
studentNumber.add(students.get(i).number);
}
studentNumber.sort(Comparator.naturalOrder());
for(int i=0;i<studentNumber.size();i++){
for(int j=0;j<students.size();j++){
if(studentNumber.get(i).equals(students.get(j).number)){
if(students.get(j).ZhongChengJi()==-1&&students.get(j).Shuchu){
System.out.println(students.get(j).number+" "+students.get(j).name+" "+"did not take any exams");
students.get(j).Shuchu = false;
}else if(students.get(j).Shuchu){
System.out.println(students.get(j).number+" "+students.get(j).name+" "+students.get(j).ZhongChengJi());
students.get(j).Shuchu = false;
}
}
}
}
List<String> list = keChengs.keySet().stream().collect(Collectors.toList());
Collections.sort(list,new paixu());
for(String key:list){
KeCheng keCheng = keChengs.get(key);
int total = 0;int qimo = 0;int pingshi = 0;int studentShu = 0;
for(int j=0;j<students.size();j++){
for(int k=0;k<students.get(j).studentClasses.size();k++){
if(students.get(j).studentClasses.get(k).kecheng.equals(keCheng.name)){
studentShu++;
if(students.get(j).studentClasses.get(k).totalChengJi!=-1){
keCheng.total1 = true;
total = total + students.get(j).studentClasses.get(k).totalChengJi;
}
if(students.get(j).studentClasses.get(k).pingShiChengJi!=-1){
keCheng.pingshi1 = true;
pingshi = pingshi + students.get(j).studentClasses.get(k).pingShiChengJi;
}
if(students.get(j).studentClasses.get(k).qiMoChengJi!=-1){
keCheng.qimo1 = true;
qimo = qimo + students.get(j).studentClasses.get(k).qiMoChengJi;
}
}
}
}
if(keCheng.kaoShiFangShi.equals("考试")){
if(keCheng.qimo1&& keCheng.pingshi1&&keCheng.total1){
System.out.println(keCheng.name+" "+pingshi/studentShu+" "+qimo/studentShu+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}else if(keCheng.kaoShiFangShi.equals("实验")){
if(keCheng.total1){
System.out.println(keCheng.name+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}else{
if(keCheng.qimo1&&keCheng.total1){
System.out.println(keCheng.name+" "+qimo/studentShu+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}
}
for(int i=0;i<students.size();i++){
boolean has = false;
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(students.get(i).number.substring(0,6))){
if(students.get(i).ZhongChengJi()!=-1){
banJis.get(j).studentShu++;
}
has = true;
if(students.get(i).ZhongChengJi()!=-1){
banJis.get(j).ZongHe = true;
banJis.get(j).zongChengJi = banJis.get(j).zongChengJi + students.get(i).ZhongChengJi();
}
}
}
if(!has){
BanJi banJi = new BanJi();
banJi.name = students.get(i).number.substring(0,6);
if(students.get(i).ZhongChengJi()!=-1){
banJi.studentShu++;
}
if(students.get(i).ZhongChengJi()!=-1){
banJi.ZongHe = true;
banJi.zongChengJi = banJi.zongChengJi + students.get(i).ZhongChengJi();
}
banJis.add(banJi);
}
}
ArrayList<String> banjiString = new ArrayList<>();
for(int i=0;i<banJis.size();i++){
banjiString.add(banJis.get(i).name);
}
banjiString.sort(Comparator.naturalOrder());
for(int i=0;i<banjiString.size();i++){
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(banjiString.get(i))){
if(!banJis.get(j).ZongHe){
System.out.println(banJis.get(j).name+" has no grades yet");
}else{
System.out.println(banJis.get(j).name+" "+banJis.get(j).ZhongChengJi());
}
}
}
}
}
static class paixu implements Comparator<String>{
public int compare(String o,String o1) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(o,o1);
}
}
}
期中后第三次大作业：
课程成绩统计程序3错误点：
错误点1：在编写程序3的时候因为改代码内容和结构的原因将原来的重复课程信息判断的语句删掉了，导致测试点出错。新增加了重复课程信息错误的忽略判断后得到正确结果。
修改后：
错误点2：在这次新的课程成绩统计程序中，新修改了输出课程成绩的要求，要求课程的成绩输出只输出一个成绩，而我的代码输出是照搬上一次的程序，经过修改输出得到正确结果。
修改后：
错误点3，4：这次新加入的权重使得计算变得比之前要更为的复杂，为了计算权重的较为准确的值，同时为了接收权重，需要用float或double型变量去接收数据，去实现权重和的计算，而如果使用double类型进行权重乘以分成绩的情况，就有可能出现偏差，导致计算结果出现错误。同时我在考虑权重是否合理的时候，单纯的将float类型的和数据与整数1进行比较，而忽略了0.999999的情况，在这种非常接近的数据面前也是符合权重和为1的情况，将不等于1的判断条件改为三位数区间外之后，得到正确结果。
修改后：
错误点5：经过反复的测试我忽略了几种特殊的成绩混合判断情况的发生，如当我录入了一个实验课程，而我又录入一个以该课程为课程的必修样式的成绩，只输入两个成绩，或者一个以该课程为课程的选修样式的成绩，只输入一个成绩，我的程序不会报错，而是会把该条成绩信息按必修或者选修的课程成绩进行正常的录入，导致不会输出报错语句而是输出正常的学生成绩，课程成绩，班级成绩等信息。经过对if语句判断条件的修改，增加对以上情况的处理，得到正确结果。
修改后：
主体代码如下：
class Play{//主体运行界面
public void startIt(){
Scanner input = new Scanner(System.in);
String s = input.nextLine();
Juage juage = new Juage();//创建判断类
ArrayList<Student>students = new ArrayList<>();
ArrayList<BanJi> banJis = new ArrayList<>();
HashMap<String,KeCheng> keChengs = new HashMap<>();//创建课程的数组
while(true){
String[] arrs = s.split(" ");//分割
if(s.equals("end")){//退出
break;
}
else if(juage.JuageBiXiuClassInput2(s)||juage.JuageXuanXiuClassInput2(s)){
System.out.println(arrs[0]+" "+": "+"course type & access mode mismatch");
}
else if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)||juage.JuageXuanXiuClassInput(s)){//必修课程和选修课程
if(juage.JuageKeChengName(arrs[0])){//课程超长名字
System.out.println("wrong format");
}
else if(!keChengs.containsKey(arrs[0])){
KeCheng keCheng = new KeCheng();
if(juage.JuageBiXiuClassInput(s)||juage.JuageBiXiuClassInput1(s)){
float all = 0;
all = all + Float.valueOf(arrs[3]) + Float.valueOf(arrs[4]);
if(arrs.length!=5){
all = 1;
}
if(all>1.001||all<0.999){
System.out.println(arrs[0]+" : weight value error");
}else{
keCheng.FloatArrayList.add(Float.valueOf(arrs[3]));
keCheng.FloatArrayList.add(Float.valueOf(arrs[4]));
if(juage.JuageBiXiuClassInput(s)){
keCheng.set(arrs[0],arrs[1],"考试");
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
}
keChengs.put(arrs[0],keCheng);//存入数组
}
}else{
keCheng.set(arrs[0],arrs[1],arrs[2]);
keChengs.put(arrs[0],keCheng);//存入数组
}
}
}else if(juage.JuageShiYanclassInput(s)){//实验
float all = 0;
for(int i=4;i<arrs.length;i++){
all = all + Float.valueOf(arrs[i]);
}
if(!keChengs.containsKey(arrs[0])){
if(juage.JuageKeChengName(arrs[0])||Integer.valueOf(arrs[3])>9||Integer.valueOf(arrs[3])<4){//课程超长名字
System.out.println("wrong format");
}else if(!juage.JuageShiYanclassInput2(s)){
System.out.println(arrs[0]+" "+": "+"course type & access mode mismatch");
}else if((arrs.length-4)!=Integer.valueOf(arrs[3])){
System.out.println(arrs[0]+" : "+"number of scores does not match");
}else if(all>1.001||all<0.999){
System.out.println(arrs[0]+" : weight value error");
}
else{
KeCheng keCheng = new KeCheng();
keCheng.set(arrs[0],arrs[1],arrs[2]);
for(int i=0;i<Integer.valueOf(arrs[3]);i++){
keCheng.FloatArrayList.add(Float.valueOf(arrs[i+4]));
}
keChengs.put(arrs[0],keCheng);//存入数组
}
}
}
else if(juage.JuageStudentPingShi(s)) {//学生信息含平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考察")|| keCheng.kaoShiFangShi.equals("实验")){
boolean has = false;
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]),keCheng);
}
}
if(!getin){
student.setStudentClasses(arrs[2],Integer.valueOf(arrs[3]),Integer.valueOf(arrs[4]),keCheng);
students.add(student);
}
}
}else if(juage.JuageStudentNoPingShi(s)){//无平时成绩
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(keCheng.kaoShiFangShi.equals("考试")||keCheng.kaoShiFangShi.equals("实验")){
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]),keCheng);
}
}
if(!getin){
student.setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]),keCheng);
students.add(student);
}
}
}
else if(arrs.length>=6){//实验
Student student = new Student();
boolean getin = false;
student.set(arrs[0],arrs[1]);
KeCheng keCheng = keChengs.get(arrs[2]);
boolean getin2 = true;
if(keChengs.get(arrs[2])!=null){
if(arrs.length>4&&(arrs.length-3==keChengs.get(arrs[2]).FloatArrayList.size())&&keChengs.get(arrs[2]).FloatArrayList.size()>=4){
for(int i=3;i<arrs.length;i++){
if(Integer.valueOf(arrs[i])<0||Integer.valueOf(arrs[i])>100){
System.out.println("wrong format");
getin2 = false;
break;
}
}
}
}else{
for(int i=3;i<arrs.length;i++){
if(Integer.valueOf(arrs[i])<0||Integer.valueOf(arrs[i])>100){
System.out.println("wrong format");
getin2 = false;
break;
}
}
}
if(getin2){
if(!keChengs.containsKey(arrs[2])){
System.out.println(arrs[2]+" "+"does not exist");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}else if(!keCheng.kaoShiFangShi.equals("实验")||arrs.length!=keChengs.get(arrs[2]).FloatArrayList.size()+3){
System.out.println(arrs[0]+" "+arrs[1]+" "+": access mode mismatch");
boolean has = false;
for(int i=0;i<students.size();i++){
if(students.get(i).number.equals(arrs[0])){
has = true;
}
}
if(!has){
students.add(student);
}
}
else{
for(int u=0;u<students.size();u++){
if(students.get(u).number.equals(student.number)){//同一学生不同学科
getin = true;
students.get(u).setStudentClasses(arrs[2],-1,Integer.valueOf(arrs[3]),keCheng);
}
}
if(!getin){
float grade = 0;
for(int i=3;i<arrs.length;i++){
grade = Integer.valueOf(arrs[i])*keCheng.FloatArrayList.get(i-3) + grade;
}
student.setStudentClasses(arrs[2],-1, (int)(grade) ,keCheng);
students.add(student);
}
}
}
}
else{//错误输入
System.out.println("wrong format");
}
s = input.nextLine();//再次输入
}
ArrayList<String> studentNumber = new ArrayList<>();
for(int i=0;i<students.size();i++){
studentNumber.add(students.get(i).number);
}
studentNumber.sort(Comparator.naturalOrder());
for(int i=0;i<studentNumber.size();i++){
for(int j=0;j<students.size();j++){
if(studentNumber.get(i).equals(students.get(j).number)){
if(students.get(j).ZhongChengJi()==-1&&students.get(j).Shuchu){
System.out.println(students.get(j).number+" "+students.get(j).name+" "+"did not take any exams");
students.get(j).Shuchu = false;
}else if(students.get(j).Shuchu){
System.out.println(students.get(j).number+" "+students.get(j).name+" "+students.get(j).ZhongChengJi());
students.get(j).Shuchu = false;
}
}
}
}
List<String> list = keChengs.keySet().stream().collect(Collectors.toList());
Collections.sort(list,new paixu());
for(String key:list){
KeCheng keCheng = keChengs.get(key);
int total = 0;int qimo = 0;int pingshi = 0;int studentShu = 0;
for(int j=0;j<students.size();j++){
for(int k=0;k<students.get(j).studentClasses.size();k++){
if(students.get(j).studentClasses.get(k).kecheng.equals(keCheng.name)){
studentShu++;
if(students.get(j).studentClasses.get(k).totalChengJi!=-1){
keCheng.total1 = true;
total = total + students.get(j).studentClasses.get(k).totalChengJi;
}
if(students.get(j).studentClasses.get(k).pingShiChengJi!=-1){
keCheng.pingshi1 = true;
pingshi = pingshi + students.get(j).studentClasses.get(k).pingShiChengJi;
}
if(students.get(j).studentClasses.get(k).qiMoChengJi!=-1){
keCheng.qimo1 = true;
qimo = qimo + students.get(j).studentClasses.get(k).qiMoChengJi;
}
}
}
}
if(keCheng.kaoShiFangShi.equals("考试")){
if(keCheng.qimo1&& keCheng.pingshi1&&keCheng.total1){
System.out.println(keCheng.name+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}else if(keCheng.kaoShiFangShi.equals("实验")){
if(keCheng.total1){
System.out.println(keCheng.name+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}else{
if(keCheng.qimo1&&keCheng.total1){
System.out.println(keCheng.name+" "+total/studentShu);
}else{
System.out.println(keCheng.name+" has no grades yet");
}
}
}
for(int i=0;i<students.size();i++){
boolean has = false;
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(students.get(i).number.substring(0,6))){
if(students.get(i).ZhongChengJi()!=-1){
banJis.get(j).studentShu++;
}
has = true;
if(students.get(i).ZhongChengJi()!=-1){
banJis.get(j).ZongHe = true;
banJis.get(j).zongChengJi = banJis.get(j).zongChengJi + students.get(i).ZhongChengJi();
}
}
}
if(!has){
BanJi banJi = new BanJi();
banJi.name = students.get(i).number.substring(0,6);
if(students.get(i).ZhongChengJi()!=-1){
banJi.studentShu++;
}
if(students.get(i).ZhongChengJi()!=-1){
banJi.ZongHe = true;
banJi.zongChengJi = banJi.zongChengJi + students.get(i).ZhongChengJi();
}
banJis.add(banJi);
}
}
ArrayList<String> banjiString = new ArrayList<>();
for(int i=0;i<banJis.size();i++){
banjiString.add(banJis.get(i).name);
}
banjiString.sort(Comparator.naturalOrder());
for(int i=0;i<banjiString.size();i++){
for(int j=0;j<banJis.size();j++){
if(banJis.get(j).name.equals(banjiString.get(i))){
if(!banJis.get(j).ZongHe){
System.out.println(banJis.get(j).name+" has no grades yet");
}else{
System.out.println(banJis.get(j).name+" "+banJis.get(j).ZhongChengJi());
}
}
}
}
}
static class paixu implements Comparator<String>{
public int compare(String o,String o1) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(o,o1);
}
}
}
四.主要困难以及改进建议
困难1：在期中后第一次大作业写课程成绩程序1时遇到了无法正确排序课程的情况，在中英文混合的情况下我无法输出和样例一样的结果，导致答案出错。
改进1：我使用了String类型的List来接收KeCheng中的KeySet，然后通过Collections.sort，结合我改写过的paixu方法带上list进行中英文混合排序，再通过排完序的list利用for循环在Kecheng中找到符合的Kecheng进行输出。
困难2：在期中后第二次大作业写课程成绩程序2时遇到了无法准确计算班级成绩的问题，经过检查发现不知道怎么准确统计每一个学生的成绩，到对应的班级当中去。
改进2：我使用ArrayList存储学生，先处理好学生的所有信息，然后运用双循环将学生分类，从不同的学生中创造新的班级，并把相符合的学生存到那些班级当中，再输出分配好的新的班级。
困难3：在期中后第三次大作业写课程成绩程序3时遇到了无法判断怎样算权重和为1的情况，导致自己很多点过不去。
改进3：在经过一定的实验和测试之后，我将判断条件从不为1改为了一个两位数的区间内，我发现计算出来的权重是一个浮点数，不能单单靠等于1来判断他是不是正确的权重。
五.总结
学习收获
通过这几周的学习，相比前一个月，我的编程能力得到了一定程度的提高，虽然我的编写依旧处于从慢到快的艰难过程，至少在结构编写上我有了更加清晰的思路去编写，在分析需求上和功能要求上比以前更加的准确和自然。学习编程不同于其他科目，对于数学等科目，你可以从目录进行一步一步的学习，有着一定的方向。而对于java的学习，感觉我一直在平行线上运动，遇到困难进行查阅解决，许多的知识都是相平行的，如果你发掘自己在某方面出现了不足，想要实现该功能却没有恰当方法，就会去学习新的编程知识，这种学习习惯的养成很大程度上是java学习所赋予我的。
1.我深入学习了对判断语句非常有用的正则表达式。正则表达式具有很多的优点：它帮助我匹配我所需要去判断的语句，类似于string类的matches()方法，正则表达式会与匹配语句进行对比，再给出判断的结果返回boolean值。熟练营用正则表达式，在捕获字符串上，匹配纯文本上有具有一定的优势，而且对于代码的节省很有作用。
2.我学习了java语法中的List泛型和Hash类型的方法。我可以通过List泛型消除强制类型转换，同时可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。我可以用hashset去重，可以用来去除集合中的重复元素。可以判断元素是否存在，使用 HashSet 的 contains() 方法来判断集合中是否包含某个元素。还可以进行元素的快速查找，HashSet 具有较快的查找速度，因为它使用的是散列表，所以可以在常数时间内查找元素。除此之外还能维护一个无序的集合，如果需要维护一个无序的集合，可以使用 HashSet 来实现。
3.我进一步的了解了关于JAVA中类，方法，属性之间的关系，在运用三者时，我从一开始的主函数功能堆积到现在的开始类与类分工，在结构和功能拆解上学到了很多新东西，这些知识对于我以后编写更长，功能更多，题目更复杂的代码能够保持清晰的思路，在修改代码纠正错误时也更加方便。并且我对于类的构建也越来越专业化和单一化，一个类所具有的功能不应该是多方面而繁琐的，应该是单一而有效的。
学习不足
通过这几周的学习，我虽然一直在学习，但是编程路上要记住的风景实在是太多了，我依然有很多不懂与不足的地方，这些弱点需要我去攻克，去破解。经过自我思考，我发现自己在以下几个方面需要去自我进一步的提升。
1.自己所编写的程序的代码量还是太大，相比其他人而已，编写同一次作业我需要差不多多100多行的代码，我尝试过缩减但是效果并不好，必须从整体上去进行改善，不然无法起到有效的代码删减，太多的代码量很影响自己的修改和维护，过多的代码量也会增加不必要的内存占用。
2.我对于拿到一个问题所产生的解题思路不够清晰，经常会走许多的弯路。我很难想出妥善的解决方法，遇到了问题没有一个清晰的解题思路，没有对题意有明确的认识，不知道怎么入手这个题目。如果自己没有一个好的思路，在解决程序问题方面比有思路的同学要多花很多的时间，而做出来的程序也不比别人的好，浪费了很多的时间。
3.自己没有敢于去尝试的习惯，喜欢安于现状，在编写程序的过程中我一般就使用自己常用的东西没有想过用其它的的方法，是不想去试也是没有用过对其他的方法不熟，导致需要用到其它方法解决问题的时候不知所措，在使用日期编写时没有采用日期类而是自己编写了一个类来计算日期，这就导致我的代码量直接多了两百行，到后面自己再去学日期类又花了很长时间，还要重新写日期方面的内容。
4.自己创建的类应该更具有”高内聚低耦合“这样一种特性，功能及数据的分配上我所创建的类在很多地方有交集，这导致我的代码功能重复较高，有很多代码没有起到实质性的功能，反而复杂了本身的程序，而且占据了一定的空间，使代码在运行上花费了更多的时间。
对其他方面的建议
1.希望大作业测试点能够说明的稍微更加清晰一些，有些测试点的提示太过于模糊而重复，从非偷懒的角度，我认为重复的测试点提示对于自身代码纠正错误的帮助不大。
2.希望在java的部分重要，实用而不易发现的基础知识部分老师能够多教授一些给我们，有些知识靠自己去找有些困难。
3.自己的代码量比别人的总是要多些，但不知道怎样去改正。
标签：输出,JAVA,int,博客,课程,arrs,juage,成绩 From： https://www.cnblogs.com/8318xwz/p/17490700.html