面向对象程序编程6-8次PTA题目集（成绩计算系列）的总结性Blog
（1）前言：
第六次PTA题目集：
知识点：此次PTA题目仅只有这一个题目，主要考的内容就是对类的使用（类似现实，对有关联的各个数据合并在一起，便于一起使用），运用正则表达式（比较苦难使用，要记住那些符号对应那些匹配，而且匹配的机制非常严格，常常想要达到预期的匹配效果需要经过很多次的调试，常用于对输入数据的合法性判断，难用，但是也非常实用），数组列表，对数组列表的接口类Comparable(在对数组列表中的内容的排序非常方便，而且内部的CompareTo可以自行定义升序降序或者其他的排序方法，常用好用)，还有对字符串的分割（sqilt），对字符串的部分截取(subString)，对输入的数据 的解析（根据输入的一行数据，来判断这行数据大体要干嘛，然后调用特定的方法来对这串字符串进行解析），比较字符串（equals,这个与==的比较方法就完全不同,==可以用来比较基本类型的值，也可以用来比较引用类型的地址值；equals则不能用来比较基本类型的值，可以比较引用类型的地址值，相对的可以在需要的类中重写equals方法，使得可以比较对象中的特定内容，例如String类就可以比较不同类中的字符串内容了），控制输出的格式（String.format("%d",12345);和与c语言格式化输出大同小异的system.out.printf(""），这个主要是用于控制一些小数的精确程度)，对实际问题的合法性判断（在PTA里这个要先判断，不行要立即return，不能用if-else放到后边else里判断，不然测试点是通过不了的，其他的放到踩坑心得里说）
这次的题量一般般，就只有一道关于系统的题目，也算是中规中矩的题目量。而且难度也不是特别大，根据之前的对菜单的写法，类似的套用即可快速写出，把学生类当作桌号，把选课当作菜单中的订单记录即可
第七次PTA题目集：
知识点：此次pta题目集主要的内容就是对上一次的成绩管理系统的升级的学习进阶，其他的知识点还有关于hashMap的使用，包含检索（Map中含键值对，根据键值对中的键来便捷的寻找对应的值，类似于数组列表中的For加强循环来找到对应的数据，时间上感觉要比数组列表要更快一点点），，包含排序的使用（这个列表的排序就比较麻烦了，没有数组列表的对数组列表的接口类Comparable的Collections.sort好用）
成绩管理系统二相比于上一次，新添加了对实验课的解析酸成绩，考点于上次成绩管理系统类似，只是多了个对系统的更新的考点（要使代码足够具有灵活性，能够随时加入新的东西）
题目难度：小题目里就只是考了HashMap 的基础知识，只要搜一下Hashmap的性质和所有方法就可以写了，还算是基础题 比较简单，就是在对hashMap使用迭代器或者加强遍历循环的时候比较麻烦，不如数组列表，但是形似函数映射的对应关系，在根据特征查找对应值得时候会更方便。然后是成绩管理系统系列题2，只是在1的基础上新加了个实验课，实验课，略有难度：主要是实验课可以根据需要，用户自定义该实验课的成绩数量，然后我方不仅根据用户的输入来进行可变化的合法性判断，还要能算出最终成绩。总体上难度一般，花的时间还是比较少的。
第八次PTA题目集：
知识点：主要考了数组列表，借口，和数组列表的排序对数组列表的接口类Comparable(在对数组列表中的内容的排序非常方便，而且内部的CompareTo可以自行定义升序降序或者其他的排序方法，常用好用)，还有对字符串的分割（sqilt），对字符串的部分截取(subString）
成绩管理系统三相对于前一次主要添加了以下新功能：用户可以自定义各个成绩的所占权重（包括考试，考察，实验课程），优化了实验课的用户自定义。同第二次，考点是对要使代码足够具有灵活性，能够随时加入新的东西。但是相对第二次更麻烦。因为多了个考点，对代码运行时间的把控，对代码占内存的把控。
难度：相比前两次，只是加个权重和修改实验课的解析逻辑，但是却比上次难度，难了很多，花了很多时间，两天时间一天到晚都在写，最后只拿了个64分。最难点的地方就在对代码运行时间和内存的把控（这个坑，我放到踩坑心得细讲），我前几次提交基本所有测试点都超时了，写是写对了，但是超时了，一分也没有，难就难在不仅要更新，还需要把此前的代码每个地方都要换成运行更快的代码，比如加强循环改成迭代器，少用循环等等
（2）设计与分析：
题目集6的作业：
7-1 课程成绩统计程序-1
设计与解释：大体的思路
根据需求，除了Main类外还设计这几个类：学生类：相当于菜单中的桌号，班级类：相当于菜单中的一个餐馆，课程类：相当于菜单系列当中的菜谱信息，选课类：相当于菜单中的客人的点单记录，成绩类：相当于自定义菜单中菜谱的价格信息，考试成绩类,考察成绩类，字符串解析类（正则表达式），在学生类中：学号，姓名，总成绩，计算总成绩的方法，自己的选课的数组列表，关于自己的学号排序的接口；班级类：班级号，学生数组列表，计算班级总成绩的方法；课程类：课程名字，考核方式，所属类型，计算总成绩的方法；选课类：组合了学生类，课程类，成绩类；成绩类：当中含有该科目的期中，期末成绩和总成绩
由于代码比较大，这里就展示Main函数里面的代码，其余代码在附录里面观看
分析：首先Main函数读取字符串，然后对输入的字符串进行解析，书写相关的正则表达式，对于相匹配的正则表达式调用不同的方法来解析不同的字符串，然后根据类别不同分别存入学生，班级，课程，选课，报错信息，等等信息，最后根据这些类之间的联系来设计解析类，对成绩的运算，最后将需要展示的信息全部按顺序展示出来，在大体框架完成后，将代码进行优化，比如按照题目要求对报错或者特殊异常处理进行处理，多调试几次就可以了
心得：关于系统的写法java中大多大同小异，认真写过一两次系统就差不多了，后面都可以套用这个模板来进行写作
题目集7的作业：
7-1 容器-HashMap-检索
设计与解释：大体的思路
-
创建一个HashMap对象：使用HashMap类的构函数来创建一个HashMap实例，例如：
java复制代码HashMap<KeyType, ValueType> hashMap = new HashMap<>(); -
插入元素到HashMap中：使用
put()方法将键值对插入到HashMap)可以是任意类型。例如：java复制代码hashMap.put(key1, value1); hashMap.put(key2, value); // 依此类推插入所有需要的. 执行检索操作：使用`get()`方法来检索指定键对应的值。例如： ```java ValueType result = hashMap.get(key);注意，如果没有找到指定的键，
get()方法将返回null。
整体思路：
- 创建HashMap对象。
- 根据题目要求或者输入的数据，使用
put()方法将键值对插入HashMap中。 - 根据需要执行多次检索操作，使用
get()方法根据键检索对应的值，并将结果存储在需要的变量中。
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Cla cla = new Cla();
String analyseString = in.nextLine();
while (!analyseString.equals("end"))
{
String[] item = analyseString.split(" ");
String num = item[0];
String name = item[1];
String score = item[2];
Student student = new Student(num,name,score);
cla.addStudent(num,student);
analyseString = in.nextLine();
}
while (in.hasNext())
{
analyseString = in.nextLine();
Student theStudent=cla.findStudent(analyseString);
if(theStudent==null)
{
System.out.println("The student "+analyseString+" does not exist");
//The student 20202316 does not exist
}
else
{
System.out.println(theStudent.num+" "+theStudent.name+" "+theStudent.score);
}
}
}
}
class Student
{
String num;
String name;
int score;
Student(String num,String name,String score)
{
this.num=num;
this.name=name;
this.score=Integer.parseInt(score);
}
}
class Cla
{
HashMap<String,Student> students = new HashMap<>();
public void addStudent(String num,Student student)
{
students.put(num,student);
}
public Student findStudent(String num)
{
if(!students.containsKey(num))
{
return null;
}
return students.get(num);
}
}
分析：hashMap的使用，包含检索（Map中含键值对，根据键值对中的键来便捷的寻找对应的值，类似于数组列表中的For加强循环来找到对应的数据，时间上感觉要比数组列表要更快一点点
7-2 容器-HashMap-排序
设计与解释：大体的思路
-
创建一个HashMap对象并插入键值对。
java复制代码HashMap<KeyType, ValueType> hashMap = new HashMap<>(); hashMap.put(key1, value1); hashMap.put(key2, value2); // 添加更多的键值对... -
将HashMap转为List，并使用Collections类的
sort()方法对列表进行排序。java复制代码List<Map.Entry<KeyType, ValueType>> list = new ArrayList<>(hashMap.entrySet()); Collections.sort(list, new Comparator<Map.Entry<KeyType, ValueType>>() { public int compare(Map.Entry<KeyType, ValueType> o1, Map.Entry<KeyType, ValueType> o2) { // 根据需要的比较逻辑进行排序，例如按键升序：return o1.getKey().compareTo(o2.getKey()); } });这里使用了匿名内部类来定义比较器，你可以根据需要自定义比较逻辑（如按键升序、按值升序等）。
-
遍历排序后的列表，获取排序后的键和值。
java复制代码for (Map.Entry<KeyType, ValueType> entry : list) { KeyType key = entry.getKey(); ValueType value = entry.getValue(); // 根据需求使用键和值进行进一步操作 }
整体思路：
- 创建HashMap对象并插入键值对。
- 将HashMap转换为List，并使用Collections类的
sort()方法对列表进行排序，定义自定义的比较逻辑。 - 遍历排序后的列表，获取键和值，根据一步操作。
-
import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); Analyse analyse = new Analyse(); String analyseString = in.nextLine(); while (!analyseString.equals("end")) { analyse.analyse(analyseString); analyseString = in.nextLine(); } analyse.showStu(); // Collections.sort(); } } class Analyse { Cla cla = new Cla(); //ArrayList<Student> students = new ArrayList<>(); public void analyse(String string1) { String[] item = string1.split(" "); String num = item[0]; String name = item[1]; String score = item[2]; Student student = new Student(num,name,score); // students.add(student); cla.addStudent(num,student); } public void showStu() { List<Map.Entry<String,Student>> students = new ArrayList<>(cla.students.entrySet()); // ArrayList<Student> students = new ArrayList<>(cla.students.values()); Collections.sort(students, new Comparator<Map.Entry<String,Student>>() { @Override public int compare(Map.Entry<String, Student> o1, Map.Entry<String, Student> o2) { return o2.getValue().num.compareTo(o1.getValue().num); } }); for(Map.Entry<String,Student> theStudent:students) { System.out.println(theStudent.getValue().num+" "+theStudent.getValue().name+" "+theStudent.getValue().score); } } } class Student implements Comparable<Student> { String num;//就目前实验所得，比较只能用于比较本类的数组列表，而比较器可以比较任意类的数组列表--- String name; int score; Student(String num, String name, String score) { this.num = num; this.name = name; this.score = Integer.parseInt(score); } public int compareTo(Student o) { return o.num.compareTo(this.num); } } class Cla { HashMap<String, Student> students = new HashMap<>(); public void addStudent(String num, Student student) { students.put(num, student); } public Student findStudent(String num) { if (!students.containsKey(num)) { return null; } return students.get(num); } public HashMap<String,Student> getStudents() { return students; } }分析：包含排序的使用（这个列表的排序就比较麻烦了，没有数组列表的对数组列表的接口类Comparable的Collections.sort好用）
7-3 课程成绩统计程序-2
设计与解释：大体的思路
根据需求，除了Main类外还设计这几个类：学生类：相当于菜单中的桌号，班级类：相当于菜单中的一个餐馆，课程类：相当于菜单系列当中的菜谱信息，选课类：相当于菜单中的客人的点单记录，成绩类：相当于自定义菜单中菜谱的价格信息，考试成绩类，实验成绩类，考察成绩类，字符串解析类（正则表达式），在学生类中：学号，姓名，总成绩，计算总成绩的方法，自己的选课的数组列表，关于自己的学号排序的接口；班级类：班级号，学生数组列表，计算班级总成绩的方法；课程类：课程名字，考核方式，所属类型，计算总成绩的方法；选课类：组合了学生类，课程类，成绩类；成绩类：当中含有该科目的期中，期末成绩和总成绩,相比于上次，多了个实验课成绩的分析
代码较大，其他主要类已经在设计里做了解释，故这里仅放出正则表达式方法里的代码，其余代码将放在下方的附录当中
分析:成绩管理系统二相比于上一次，只是在1的基础上新加了个实验课，实验课，略有难度,，考点于上次成绩管理系统类似，只是多了个对系统的更新的考点（要使代码足够具有灵活性，能够随时加入新的东西）,首先Main函数读取字符串，然后对输入的字符串进行解析，书写相关的正则表达式，对于相匹配的正则表达式调用不同的方法来解析不同的字符串，然后根据类别不同分别存入学生，班级，课程，选课，报错信息，等等信息，最后根据这些类之间的联系来设计解析类，对成绩的运算，最后将需要展示的信息全部按顺序展示出来，在大体框架完成后，将代码进行优化，比如按照题目要求对报错或者特殊异常处理进行处理，多调试几次就可以了
心得：基础不好，地动山摇，虽然成绩管理系统逸简单，但是却是后面的每一步的基础。写代码也需要循序渐进的写。
PTA题目集8的作业：
关于题目集8中除了成绩管理系统系列的题目外，其他的题目主要就是考数组列表，比较简单，这里就不过多赘述
大概数组列表，对数组列表的接口类Comparable就考这些，7-1 容器-ArrayList-排序，7-3 jmu-Java-02基本语法-03-身份证排序，7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack，7-5 jmu-Java-03面向对象基础-05-覆盖
7-2 课程成绩统计程序-3
设计与解释：大体的思路
根据需求，除了Main类外还设计这几个类：学生类：相当于菜单中的桌号，班级类：相当于菜单中的一个餐馆，课程类：相当于菜单系列当中的菜谱信息，选课类：相当于菜单中的客人的点单记录，成绩类：相当于自定义菜单中菜谱的价格信息，考试成绩类，实验成绩类，考察成绩类，字符串解析类（正则表达式），在学生类中：学号，姓名，总成绩，计算总成绩的方法，自己的选课的数组列表，关于自己的学号排序的接口；班级类：班级号，学生数组列表，计算班级总成绩的方法；课程类：课程名字，考核方式，所属类型，计算总成绩的方法；选课类：组合了学生类，课程类，成绩类；成绩类：当中含有该科目的期中，期末成绩和总成绩,相比于上次， 不仅多了个实验成绩，而且还需要对权重进行分析
分析:相比于上次， 不仅多了个实验成绩，而且还需要对权重进行分析首先Main函数读取字符串，然后对输入的字符串进行解析，书写相关的正则表达式，对于相匹配的正则表达式调用不同的方法来解析不同的字符串，然后根据类别不同分别存入学生，班级，课程，选课，报错信息，等等信息，最后根据这些类之间的联系来设计解析类，对成绩的运算，最后将需要展示的信息全部按顺序展示出来，在大体框架完成后，将代码进行优化，比如按照题目要求对报错或者特殊异常处理进行处理，多调试几次就可以了
（3）采坑心得：
1.对于实际问题的合法性判断：这个是我在PTA遇到的第一个百思不得其解的坑，也是偶然中发现的，先单纯说在作业上：对于有关于合法性判断的测试点，必须得将合法性判断置于代码的最上边位置，不合格则立即return退出程序或者跳过一段程序。如果将合法判断置于后面，比如if-else放在else后面，即使最后运行结果一样，但是这个测试点就是不通过。总结就是在运行某段代码前，先判断是否合法，合法则执行这段代码，不合法则不执行这段代码直接跳过。然后在代码上的理解：我认为这样的好处是可以使代码运行的更快，因为当不合格时便不会读取其他多余的代码。
2.对代码运行时间和内存的把控：在PTA里面写这种系列更新题目的后期最大难题，你会是会写，但是你不会要会写，你还要智写，不能随便叠代码来完成，得用一些更高级的代码来替代那些简单代码以来减少运行时间。不仅是这次成绩管理系统，包括上次的菜单系统，越更新到后面，就越容易测试点超时。不能总是用循环来干事，得多换成迭代器，多用继承和组合加强代码复用
3.单词排序：先对长度排序，再在同长里面调用compareToIgnoreCase（）方法。因为compareToIgnoreCase（）函数在队不同长度的单词进行排序时会出现排不准的情况。还有也不能用compareTo（）方法，这个方法会考虑单词的大小写，让排序不准确，题目准确写了忽略大小写，故用compareToIgnoreCase（）才是最优解，可以忽略单词的大小写进行比较。
4.快读快写：用快读快写时，一定要记得在方法标签后面＋throws IOException，不然是运行不了的。而且在创建对象时的代码是很长的，不好记而且容易打错，所以建议把创建对象的代码复制到一个常用代码文档里，要用的时候就不用再打一遍了。
（4）改进建议：
1.写代码的时的细节问题和全局思想问题：写代码时总是会遗漏；{}等小细节问题，导致很多时候一运行报错了，到处找错误找不到，费了一番功夫才发现原来是某个小细节问题，同时也归咎于没有养成在报错的时候仔细看Idea给的报错可能，因为是英文所以老是懒得看。全局思想是常常遇到题目就开始写，并没有构思一下
2.数据的重复与排序：有关重复数据和排序的，当时还不知道哈希表，就只能一股脑的用循环嵌套去解决，十分的麻烦，而且经常会测试点超时。比如的数据就可以直接全部add入哈希表中，然后再将删除重复数据的哈希表内个数与原个数比较就行。同理，最后遍历输出就行，可以极大的简化代码。
（5）总结：
知识上：学到了队类的使用，封装，String类，日期类，包装类中的一些方法，哈希表，数组列表，equals与==的不同等
思路上：学到了基本的解题步骤，需求分析，不断分解成子问题，由下向上逐步解决，阶段性调试测试，先构建出基本框架，写出基本功能，检查Bug，最后再来对整体的优化（比如让界面更简洁啊，简化一些代码啊等等）
当然还有很多没有弄明白的方面，还在学习正则表达式
（6）成绩管理系统一的代码附录
import java.text.Collator;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Analyse analyse = new Analyse();
String string1 = in.nextLine();
while (!string1.equals("end"))
{
analyse.stringAnalyse(string1);
string1= in.nextLine();
}
analyse.showError();
analyse.showStu();
analyse.showCourse();
analyse.showCla();
}
}
class Student implements Comparable<Student>{
String name;
String num;
int average;
ArrayList<Select> selects = new ArrayList<Select>();
Student(String name,String num)
{
this.name = name;
this.num=num;
}
public Select addSelect(Select select)
{
selects.add(select);
return select;
}
public void sumAverage()
{
int total = 0;
for(Select temp:selects)
{
total = total+temp.score.totalScore;
}
if(selects.size()==0)
return;
this.average=total/(selects.size());
}
@Override
public int compareTo(Student o) {
return this.num.compareTo(o.num);
}
}
class Cla implements Comparable<Cla>{
String num;
ArrayList<Student> students = new ArrayList<Student>();
int classAverage;
Cla(String num)
{
this.num=num;
}
public Student addStudent(Student student)
{
students.add(student);
return student;
}
public void sumAverage()
{
int total = 0;
for(Student temp:students)
{
total = total+temp.average;
}
if(students.size()==0)
return;
this.classAverage=total/(students.size()); }
@Override
public int compareTo(Cla o) {
return this.num.compareTo(o.num);
}
}
class Course implements Comparable<Course>{
String name;
String type;
String method;
int courseAverage;
int finalaverage;
int usualaverage;
ArrayList<Select> selects = new ArrayList<Select>();
Course(String name,String type,String method)
{
this.name=name;
this.type=type;
this.method=method;
}
public Select addSelect(Select select)
{
selects.add(select);
return select;
}
public void sumAverage()
{
int total = 0;
for(Select temp:selects)
{
total = total+temp.score.totalScore;
}
if(selects.size()==0)
return;
this.courseAverage=total/(selects.size());
}
public void finalaverage()
{
int total = 0;
for(Select temp:selects)
{
total = total+temp.score.finalScore;
}
if(selects.size()==0)
return;
this.finalaverage=total/(selects.size());
}
public void usualaverage()
{
int total = 0;
for(Select temp:selects)
{
total = total+temp.score.usualScore;
}
if(selects.size()==0)
return;
this.usualaverage=total/(selects.size());
}
public int compareTo(Course o) {
Comparator<Object> compare = Collator.getInstance(java.util.Locale.CHINA);
return compare.compare(name,o.name);
}
}
class Select {
Course course;
Student student;
Score score;
Select(Course course,Student student,Score score)
{
this.course=course;
this.student=student;
this.score=score;
}
}
abstract class Score {
int totalScore;
int finalScore;
int usualScore;
}
class ExamScore extends Score{
ExamScore(int usualScore,int finalScore)
{
this.usualScore=usualScore;
this.finalScore=finalScore;
this.totalScore=(int)(finalScore*0.7f+usualScore*0.3f);
}
}
class ExploreScore extends Score{
ExploreScore(int finalScore)
{
this.finalScore=finalScore;
this.totalScore=finalScore;
}
}
class Analyse {
ArrayList<Student> students = new ArrayList<>();
ArrayList<Course> courses= new ArrayList<>();
ArrayList<Cla> clas = new ArrayList<>();
ArrayList<Select> selects = new ArrayList<>();
ArrayList<String> errors = new ArrayList<>();
public void stringAnalyse(String string)
{
if(InputMatching.matchingInput(string)==0)
{
String error = "wrong format";
errors.add(error);
return;
}
String[] item = string.split(" ");
if(item.length==3||item.length==2)
{
String name = item[0];
String type = item[1];
String method="";
if(item.length==3) {
method = item[2];//重复课程的输入混乱，排序重复，未改-对应5异常
}
if(item.length==2)
{
if(type.equals("必修")) {
method = "考试";
}
else
{
String error = "wrong format";
errors.add(error);
return;
}
}
Course againCourse = findCourse(name);
if(againCourse!=null)
{
return;
}
if(type.equals("必修"))
{
if(method.equals("考察"))
{
String error = name+" "+": course type & access mode mismatch";
errors.add(error);
//System.out.println(name+": course type & access mode mismatch");
return;
}
Course course = new Course(name,type,method);
courses.add(course);
}
if(type.equals("选修"))
{
Course course = new Course(name,type,method);
courses.add(course);
}
}
if(item.length==4||item.length==5)
{
if(InputMatching.matchingInput(string)==0)//对应异常三，似乎还要一些测试点未达标
{
String error = "wrong format";
errors.add(error);
return;
}
String classNum = item[0].substring(0,6);
String id = item[0];
String stuName = item[1];
Cla cla1= findCla(classNum);
if(cla1==null)
{
cla1 = new Cla(classNum);
clas.add(cla1);
}
Student student1 = findStudent(stuName,id);
if(student1==null)
{
student1= new Student(stuName,id);
students.add(student1);
cla1.addStudent(student1);
}
else //重复学生成绩信息导致同一科目双倍选课，双倍课，双倍人，未改——对应5异常
{
for(Select againselect:student1.selects)
{
if(item[2].equals(againselect.course.name))
{
return;
}
}
}
//int errorSelect = 0;//两处错误报告的优先级，未改；重要-对应2异常
String courseName = item[2];
Course stuCourse = findCourse(courseName);
if(stuCourse==null)
{
String error = courseName+" "+"does not exist";
errors.add(error);
// errorSelect = 1;//已经试了一次，但是得分不变，大概率是已经完成了，存在小可能没有正确的修改导致
return;//次两处错误已经不可能同时出现，但是不排除题目意思是说，即使是不同科目出现两个错误也要选择-待验证-未改
}
if(stuCourse.method.equals("考试"))
{
if(item.length==4)
{
//if(errorSelect==0) {
String error = id + " " + stuName + " " + ": access mode mismatch";
errors.add(error);
// }
return;
}
int usualScore = Integer.parseInt(item[3]);
int finalScore = Integer.parseInt(item[4]);
Score score = new ExamScore(usualScore,finalScore);
Select select1 = new Select(stuCourse,student1,score);
selects.add(select1);
student1.addSelect(select1);
stuCourse.addSelect(select1);
student1.sumAverage();
stuCourse.sumAverage();
stuCourse.finalaverage();
stuCourse.usualaverage();
cla1.sumAverage();
}
if(stuCourse.method.equals("考察"))
{
if(item.length==5)
{
String error = id+" "+stuName+" "+": access mode mismatch";
errors.add(error);
//System.out.println(id+" "+stuName+" "+": access mode mismatch");
return;
}
int finalScore = Integer.parseInt(item[3]);
Score score = new ExploreScore(finalScore);
Select select1 = new Select(stuCourse,student1,score);
selects.add(select1);
student1.addSelect(select1);
stuCourse.addSelect(select1);
student1.sumAverage();
stuCourse.sumAverage();
stuCourse.finalaverage();
cla1.sumAverage();
}
}
}
public void showError()
{
for (String err:errors)
{
System.out.println(err);
}
}
public void showStu()
{
Collections.sort(students);
for(Student stu:students)
{
if(stu.selects.size()==0)
{
System.out.println(stu.num+" "+stu.name+" "+"did not take any exams");
}
else {
System.out.println(stu.num + " " + stu.name + " " + stu.average);
}
}
}
public void showCourse()
{
Collections.sort(courses);
for(Course cou:courses)
{
if(cou.selects.size()==0)
{
System.out.println(cou.name+" "+"has no grades yet");
}
else {
if (cou.method.equals("考试")) {
System.out.println(cou.name + " " + cou.usualaverage + " " + cou.finalaverage + " " + cou.courseAverage);
}
if (cou.method.equals("考察")) {
System.out.println(cou.name + " " + cou.finalaverage + " " + cou.courseAverage);
}
}
}
}
public void showCla()
{
Collections.sort(clas);
for(Cla cla:clas)
{
if(blankCla(cla))
{
System.out.println(cla.num+" "+"has no grades yet");
}
else {
System.out.println(cla.num + " " + cla.classAverage);
}
}
}
public boolean blankCla(Cla cla)
{
for(Student student:cla.students)
{
if(student.selects.size()!=0)
{
return false;
}
}
return true;
}
public boolean haveCla(String classNum)
{
if(clas.size()==0)
{
return false;
}
for(Cla temp:clas)
{
if(temp.num.equals(classNum))
{
return true;
}
}
return false;
}
public Course findCourse(String courseName)
{
if(courses.size()==0)
{
return null;
}
for(Course temp:courses)
{
if(temp.name.equals(courseName))
{
return temp;
}
}
return null;
}
public Student findStudent(String stuName,String stuNum)
{
if(students.size()==0)
{
return null;
}
for(Student temp:students)
{
if(temp.name.equals(stuName)&&temp.num.equals(stuNum))
{
return temp;
}
}
return null;
}
public Cla findCla(String claNum)//测试点大致测试数据与给的样例有关，看测试点名字可得，故可根据大概的测试数据
{
if(clas.size()==0)
{
return null;
}
for(Cla temp:clas)
{
if(temp.num.equals(claNum))
{
return temp;
}
}
return null;
}//来实例测试多个可能的数据，来找出与预期结果不同的数据，然后修改
}
class InputMatching {
static String stuNumMatching = "[0-9]{8}";//8个0-9的数字
static String stuNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String scoreMatching = "([1-9]?[0-9]|100)";
static String courseNameMatching = "\\S{1,10}";//1到10个非空格（TAB）字符
static String courseTypeMatching = "(选修|必修)";
static String checkcourseTypeMatching = "(考试|考察)";
//cousrInput用于定义课程信息模式（正则表达式）
static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
//scoreInput用于定义成绩信息模式（正则表达式）
static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching;
static String secondScoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
scoreMatching + " " + scoreMatching;
public static int matchingInput(String s) {
if (matchingCourse(s)) {
return 1;
}
if (matchingScore(s)||matchSecondScore(s)) {
return 2;
}
return 0;
}
private static boolean matchingCourse(String s) {
return s.matches(courseInput);
}
private static boolean matchingScore(String s) {
//System.out.println(match);
return s.matches(scoreInput);
}
private static boolean matchSecondScore(String s)
{
return s.matches(secondScoreInput);
}
}
浙公网安备 33010602011771号