java面对对象第三次博客作业
前言
第三次博客主要围绕的是最后四次pta作业以及对面向对象程序设计的心得和体会。
这四次pta难度都比较大，考察到了许多知识点，arraylist，hashset，hashmap常用方法的使用，以及对equals，hashcode方法的重写。这几次题目的难度都在于如何对输入的的数据进行一个筛选和提取。题量和难度都比较大，我自己后面几次作业也都没拿到满分。
设计与分析：
首先是统计java关键字的出现次数
这道题目的要求是注释里，字符串中出现的java关键字都不算在其中。
而我的思路就是把所有的字符串，单行注释，多行注释，运算符跟随的关键字全都删去，这样剩下的就是我需要的信息，在根据hashmap的不重复性，进行计数。本体还需要对hashmap的键进行一个排序
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
StringBuilder sourceCode = new StringBuilder();
String line;
while (!(line = scanner.nextLine()).equals("exit")) {
sourceCode.append(line).append("\n");
}
if (sourceCode.length() == 0) {
System.out.println("Wrong Format");
return;
}
Map<String, Integer> keywordCount = countKeywords(sourceCode.toString());
if (keywordCount.isEmpty()) {
return;
}
List<String> sortedKeywords = new ArrayList<>(keywordCount.keySet());
Collections.sort(sortedKeywords);
for (String keyword : sortedKeywords) {
int count = keywordCount.get(keyword);
System.out.println(count + "\t" + keyword);
}
}
private static Map<String, Integer> countKeywords(String sourceCode) {
Map<String, Integer> keywordCount = new TreeMap<>();
sourceCode = removeCommentsAndStrings(sourceCode);
String[] words = sourceCode.split("\\W+");
for (String word : words) {
if (isStringLiteral(word)) {
continue;
}
if (isKeyword(word)) {
keywordCount.put(word, keywordCount.getOrDefault(word, 0) + 1);
}
}
return keywordCount;
}
private static String removeCommentsAndStrings(String sourceCode) {
sourceCode = sourceCode.replaceAll("//.*|/\\*(.|[\\r\\n])*?\\*/", " ");
sourceCode = sourceCode.replaceAll("\".*?\"", " ");
return sourceCode;
}
private static boolean isStringLiteral(String word) {
return word.startsWith("\"") && word.endsWith("\"");
}
private static boolean isKeyword(String word) {
String[] keywords = {"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const","continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float","false","for","goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native","new","null", "package", "private", "protected", "public", "return", "short", "static", "strictfp","super", "switch", "synchronized", "this", "throw", "throws", "transient","true", "try", "void","volatile", "while"};
for (String keyword : keywords) {
if (keyword.equals(word)) {
return true;
}
}
return false;
}
}
在这道题中我设计了四个静态方法用于处理以上我所提到的字符串，运算符，单行注释，多行注释。
单行注释的处理十分简单，只要匹配到了//就把那一行删掉之后的删掉就行，多行注释就要麻烦一些，我是用到了一个标记变量来记录位置，如果这一行在注释内，标记变量为true，就会删掉这一行，并且循环中以后的语句均不执行（continue）。
删除字符串主要是用到了正则表达式记录下引号的索引并删除。
主方法中是创建了一个treemap便于直接对我的键进行一个排序，排序方法是string里的CASE_INSENSITIVE_ORDER方法。
然后再将所有的关键字都加入到treemap里。将用四个静态方法处理后的正确数据用\\\w+进行匹配分割，这样就得到了单独的单词，之后再进行遍历查询。
第十次到第十二次题目集中都有一个课程成绩统计程序，并且不断迭代，这个题目我完成的情况不是很好，没有拿到过满分，并且最后一次拿的分非常低，但是原因是因为我没看懂题目
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
ScoreAnalyzer scoreAnalyzer=new ScoreAnalyzer();
scoreAnalyzer.play();
}
}
class ScoreAnalyzer {
private List<Class> classes=new ArrayList<>();
private List<Course>courses=new ArrayList<>();
private String[]goal;
Student student;
Course course1;
StudentCourse studentCourse;
Class cla;
double regularGrade=0;
double finalGrade=0;
void pri(){
System.out.println("wrong format");
}
public void play(){
Scanner in=new Scanner(System.in);
String go=in.nextLine();
goal=go.split(" ");
String regex = "^.{1,10}$";
while (goal.length==3||goal.length==2) {
if(goal[0].matches(regex)&&(goal[1].equals("必修")||goal[1].equals("选修"))){
enterTheCourse(goal);
}else {
pri();
}
go=in.nextLine();
goal=go.split(" ");
}
while (goal.length==5||goal.length==4){
String patternNumber = "^\\d{8}$";
String patternGrade = "^(?:\\d|\\d{2}|100)$";
if(goal.length==5&&goal[0].matches(patternNumber)&&goal[3].matches(patternGrade)&&goal[4].matches(patternGrade)){
enteTheCourseGrade(goal);
} else if (goal.length==4&&goal[0].matches(patternNumber)&&goal[3].matches(patternGrade)) {
enteTheCourseGrade(goal);
}else {
pri();
}
go=in.nextLine();
goal=go.split(" ");
}
if(goal[0].equals("end")){
outputStudentGrades();
outputCourseGrades();
outPutTheTotalCourseGradeOfTheClass();
}
}
public void enterTheCourse(String[]goal){
if(!judgmentExists(goal[0])){
if(goal.length==3){
if(goal[1].equals("必修")&&goal[2].equals("考察")){
System.out.println(goal[0]+" : course type & access mode mismatch");
}else{
if(goal[2].equals("考试")||goal[2].equals("考察")){
Course course=new Course(goal[0],goal[1],goal[2]);
courses.add(course);
}else{
pri();
}
}
}
else{
Course course=new Course(goal[0],goal[1],"考试");
courses.add(course);
}
}
}
void A(){
if(goal.length==5){
regularGrade= Double.parseDouble(goal[3]);
finalGrade= Double.parseDouble(goal[4]);
}else{
finalGrade= Double.parseDouble(goal[3]);
}
}
void B(){
course1=findCourse(goal[2]);
int index=courses.indexOf(course1);
courses.get(index).setRegularGrade((int) (courses.get(index).getRegularGrade()+regularGrade));
courses.get(index).setFinalGrade((int) (courses.get(index).getFinalGrade()+finalGrade));
courses.get(index).setFlog(courses.get(index).getFlog()+1);
studentCourse=new StudentCourse(course1.getCourseName(),course1.getCourseNature(),course1.getAssessmentMode(),regularGrade,finalGrade);
}
void addA(){
A();
B();
student=new Student(goal[0],goal[1]);
student.getStudentCourses().add(studentCourse);
cla.getStudents().add(student);
classes.add(cla);
}
void addB(int index){
A();
B();
student=new Student(goal[0],goal[1]);
student.getStudentCourses().add(studentCourse);
this.classes.get(index).getStudents().add(student);
}
void addC(int index,int index1){
A();
int f=0;
for(StudentCourse sc:this.classes.get(index).getStudents().get(index1).getStudentCourses()){
if(goal[2].equals(sc.getCourseName())){
f++;
}
}
if(f==0){
B();
this.classes.get(index).getStudents().get(index1).getStudentCourses().add(studentCourse);
}
}
void enteTheCourseGrade(String[]goal){
String classNumber = goal[0].substring(0, 6);
cla=new Class(classNumber);
student=new Student(goal[0],goal[1]);
if(!judgeStudent(goal[0])){
if(!judgeClass(classNumber)){
if(!judgmentExists(goal[2])){
cla.getStudents().add(student);
classes.add(cla);
System.out.println(goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if((course.getAssessmentMode().equals("考察")&&goal.length==5)||(course.getAssessmentMode().equals("考试")&&goal.length<5)){
cla.getStudents().add(student);
classes.add(cla);
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addA();
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addA();
}
}
} else if (judgeClass(classNumber)) {
cla=findClass(classNumber);
int index=classes.indexOf(cla);
if(!judgmentExists(goal[2])){
this.classes.get(index).getStudents().add(student);
System.out.println(goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if(course.getAssessmentMode().equals("考察")&&goal.length==5){
this.classes.get(index).getStudents().add(student);
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addB(index);
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addB(index);
}
}
}
} else {
student=findStudent(goal[0]);
cla=findClass(classNumber);
int index=classes.indexOf(cla);
int index1=classes.get(index).getStudents().indexOf(student);
if(!judgmentExists(goal[2])){
System.out.println(goal[0]+" "+goal[1]+" :"+goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if(course.getAssessmentMode().equals("考察")&&goal.length==5){
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addC(index,index1);
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addC(index,index1);
}
}
}
}
void outputStudentGrades(){
Collections.sort(classes);
for (Class clazz : classes) {
clazz.sortStudentsByStudentId();
clazz.printStudentsByStudentId();
}
}
void outputCourseGrades(){
Collator collator = Collator.getInstance(Locale.CHINA);
Comparator<Course> courseComparator = Comparator.comparing(c -> c.getCourseName(), collator);
Collections.sort(courses, courseComparator);
for(Course course:courses){
course.printGradeAverage();
}
}
void outPutTheTotalCourseGradeOfTheClass(){
Collections.sort(classes);
for (Class clazz : classes) {
clazz.calculateGrade();
}
}
boolean judgmentExists(String goal){
for(Course course:courses) {
if (goal.equals(course.getCourseName())) {
return true;
}
}
if(courses.size()==0){
return false;
}
return false;
}
Course findCourse(String goal){
for(Course course:courses) {
if (goal.equals(course.getCourseName())) {
return course;
}
}
return null;
}
boolean judgeClass(String goal){
for(Class cla:classes){
if(cla.getClassNumber().equals(goal)){
return true;
}
}
if (classes.size()==0){
return false;
}
return false;
}
Class findClass(String goal){
for(Class cla:classes){
if(cla.getClassNumber().equals(goal)){
return cla;
}
}
return null;
}
boolean judgeStudent(String goal){
for(Class cla:classes){
for(Student student:cla.getStudents()){
if(student.getStudentId().equals(goal)){
return true;
}
}
if(cla.getStudents().size()==0){
return false;
}
}
if(classes.size()==0){
return false;
}
return false;
}
Student findStudent(String goal){
for(Class cla:classes){
for(Student student:cla.getStudents()){
if(student.getStudentId().equals(goal)){
return student;
}
}
}
return null;
}
}
class Course implements Comparable<Course>{
private String courseName;
private String courseNature;
private String assessmentMode;
private int regularGrade;
private int finalGrade;
private int flog=0;
private int gradeAverage=0;
public Course(String courseName, String courseNature, String assessmentMode) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMode = assessmentMode;
}
public void calculate(){
if(flog!=0){
if (this.courseNature.equals("必修")){
this.gradeAverage= (int) (this.regularGrade*0.3+this.finalGrade*0.7)/flog;
}else if(this.courseNature.equals("选修")){
if(this.assessmentMode.equals("考试")){
this.gradeAverage= (int) (this.regularGrade*0.3+this.finalGrade*0.7)/flog;
}else if(this.assessmentMode.equals("考察")){
this.gradeAverage= this.finalGrade/flog;
}
}
}
}
public void printGradeAverage(){
if(this.getAssessmentMode().equals("考察")){
calculate();
if(this.gradeAverage!=0){
System.out.println(this.getCourseName()+" "+this.getFinalGrade()/flog+" "+this.getGradeAverage());
}else{
System.out.println(this.getCourseName()+" "+"has no grades yet");
}
}else{
calculate();
if(this.gradeAverage!=0){
System.out.println(this.getCourseName()+" "+this.getRegularGrade()/flog+" "+this.getFinalGrade()/flog+" "+this.getGradeAverage());
}else{
System.out.println(this.getCourseName()+" "+"has no grades yet");
}
}
}
public String getCourseName() {
return courseName;
}
public String getCourseNature() {
return courseNature;
}
public String getAssessmentMode() {
return assessmentMode;
}
public int getRegularGrade() {
return regularGrade;
}
public void setRegularGrade(int regularGrade) {
this.regularGrade = regularGrade;
}
public int getFinalGrade() {
return finalGrade;
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFlog() {
return flog;
}
public void setFlog(int flog) {
this.flog = flog;
}
public int getGradeAverage() {
return gradeAverage;
}
@Override
public int compareTo(Course otherCourse) {
return getCourseName().compareTo(otherCourse.getCourseName());
}
}
class Class implements Comparable<Class>{
private String classNumber;
private List<Student> students=new ArrayList<>();
private List<Course> courses=new ArrayList<>();
private int classGradeAverage=0;
public void calculateGrade(){
for(Student student:students){
this.classGradeAverage=this.classGradeAverage+student.getOverallGradeAverage();
}
this.classGradeAverage=this.classGradeAverage/students.size();
if(this.getClassGradeAverage()==0){
System.out.println((this.getClassNumber()+" "+"has no grades yet").trim());
}else {
System.out.println((this.getClassNumber()+" "+this.getClassGradeAverage()).trim());
}
}
public Class(String classNumber) {
this.classNumber = classNumber;
}
public void sortStudentsByStudentId() {
Collections.sort(students);
}
public void printStudentsByStudentId() {
for (Student student : students) {
student.OverallGradeAverage();
if(student.getOverallGradeAverage()==0){
System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+"did not take any exams");
}else{
System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+student.getOverallGradeAverage());
}
}
}
@Override
public int compareTo(Class other) {
return this.classNumber.compareTo(other.getClassNumber());
}
public String getClassNumber() {
return classNumber;
}
public List<Student> getStudents() {
return students;
}
public int getClassGradeAverage() {
return classGradeAverage;
}
}
class Student implements Comparable<Student>{
private String studentId;
private String studentName;
private List<StudentCourse>studentCourses=new ArrayList<>();
private int overallGradeAverage=0;
public Student(String studentId, String studentName) {
this.studentId = studentId;
this.studentName = studentName;
}
public String getStudentId() {
return studentId;
}
public String getStudentName() {
return studentName;
}
public List<StudentCourse> getStudentCourses() {
return studentCourses;
}
public int getOverallGradeAverage() {
return overallGradeAverage;
}
public void setOverallGradeAverage(int overallGradeAverage) {
this.overallGradeAverage = overallGradeAverage;
}
public void OverallGradeAverage(){
for(StudentCourse studentCourse:studentCourses){
studentCourse.calculate();
overallGradeAverage= (int) (overallGradeAverage+studentCourse.getGradeAverage());
}
if(studentCourses.size()!=0){
overallGradeAverage/=studentCourses.size();
}
setOverallGradeAverage(overallGradeAverage);
}
@Override
public int compareTo(Student other) {
return this.studentId.compareTo(other.getStudentId());
}
}
class StudentCourse {
private String courseName;
private String courseNature;
private String assessmentMode;
private double regularGrade;
private double finalGrade;
private Double gradeAverage=0.0;
public StudentCourse(String courseName, String courseNature, String assessmentMode, double regularGrade,double finalGrade) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMode = assessmentMode;
this.regularGrade = regularGrade;
this.finalGrade = finalGrade;
}
public Double getGradeAverage() {
return gradeAverage;
}
public void calculate(){
if (this.courseNature.equals("必修")){
this.gradeAverage=this.regularGrade*0.3+this.finalGrade*0.7;
}else if(this.courseNature.equals("选修")){
if(this.assessmentMode.equals("考试")){
this.gradeAverage=this.regularGrade*0.3+this.finalGrade*0.7;
}else if(this.assessmentMode.equals("考察")){
this.gradeAverage= (double) this.finalGrade;
}
}
}
}
这道题目筛选信息十分复杂，因为输入的信息可能会出现各种错误，格式错误，信息不匹配，成绩不是整数等等，数据输入进去了，以何种方式储存和调用又是一个问题。类图虽然设计好了，但是这个类图并不完整，里面涉及到的方法和调用关系都要自己去思考。
这道题中我使用了许多个hashmap和treemap来储存数据，因为双列集合可以体现键和值的关系，但是我也因此使用了太多的hashmap，以至于我自己都有点迷糊什么自己的思路。
输入的思路：首先是第一个数据，如果是录入学生信息那么第一个数据一定是学号，可以用正则表达式进行匹配。然后就可以对这个学生信息进行一系列的筛选，比如这个信息的长度是否为四位或者五位，成绩中是否包含小数，如果这些信息都没有问题那么就创建一个学生对象。
如果第一个数据不是学号那么就录入课程信息，并且该题目要求了如果输入了重复的课程信息就只以第一个为准，那么只需要重写键的类中的hashcode和equals方法就可以实现了，并且也可以通过实现compareble接口对键进行一个排序。
对课程信息数据进行筛选时同样可以根据数据的长度，以及每个数据的要求进行筛选。
相对复杂的一些就是还要对课程的性质和课程的考试方法进行一个匹配。
如果所有的筛选都没有问题的就把创建该课程对象。并且放在我自己的创建的几个用于记录成绩的map里。因为还没有成绩，所以map里的成绩值都是0。
还有一个要注意的就是score，所有的数据筛选好了之后我同样要构建一个score类，然后score，student，course类构成一个完整的课程信息对象，再把这个课程信息对象储存起来。么这个类中就包含了所有的信息，课程，成绩，对应的学生都在其中，按道理来说我只需要一个map的对象储存起来就行，键是这个对象，值是班级。这样理论上就可以非常清晰的进行一个阅读和调用。但是自己在写这一系列的题目时都没有现在这么清晰的思路，以至于我用了许多的map来储存不同的数据。这也导致我接下来的每一次迭代都十分痛苦和麻烦。并且每一次迭代我都对我的代码进行了很大的改动，极大的增加了我的工作量。
接下来的两次题目集都分别是在这次的题目上进行了迭代，第二次题目集中加入了实验成绩，第三次题目集中修改了实验成绩的录入方式和score类的结构，这里便不再继续分析，代码在下面import java.text.Collator;
import java.text.Collator;
import java.util.*;
public class Main {
public static void main(String[] args) {
ScoreAnalyzer scoreAnalyzer=new ScoreAnalyzer();
scoreAnalyzer.play();
}
}
class ScoreAnalyzer {
private List<Class> classes=new ArrayList<>();
private List<Course>courses=new ArrayList<>();
private String[]goal;
Student student;
Course course1;
StudentCourse studentCourse;
Class cla;
double regularGrade=0,finalGrade=0;
String patternGrade = "^(?:100|[1-9]\\d|\\d)$";
void pri(){
System.out.println("wrong format");
}
public void play(){
Scanner in=new Scanner(System.in);
String go=in.nextLine();
goal=go.split(" ");
String regex = "^.{1,10}$";
while (goal.length==3||goal.length==2) {
if(goal[0].matches(regex)&&(goal[1].equals("必修")||goal[1].equals("选修")||goal[1].equals("实验"))){
enterTheCourse(goal);
}else {
pri();
}
go=in.nextLine();
goal=go.split(" ");
}
while (goal.length>=4){
String patternNumber = "^\\d{8}$";
int flog=0;
if(goal.length==5&&goal[0].matches(patternNumber)){
if(goal[3].matches(patternGrade)&&goal[4].matches(patternGrade))
{
enteTheCourseGrade(goal);
}else {
pri();
}
} else if (goal.length==4&&goal[0].matches(patternNumber)) {
if(goal[3].matches(patternGrade))
{
enteTheCourseGrade(goal);
}else {
pri();
}
} else if (goal.length>5&&(Integer.parseInt(goal[3])>9||Integer.parseInt(goal[3])<4)) {
pri();
} else if (goal.length>5&&(Integer.parseInt(goal[3])<=9&&Integer.parseInt(goal[3])>=4)) {
for(int i=4;i<goal.length;i++){
if(!goal[i].matches(patternGrade)){
flog=1;
pri();
break;
}
}
if(flog==0){
enteTheCourseGrade(goal);
}
} else {
pri();
}
go=in.nextLine();
goal=go.split(" ");
}
if(goal[0].equals("end")){
outputStudentGrades();
outputCourseGrades();
outPutTheTotalCourseGradeOfTheClass();
}
}
public void enterTheCourse(String[]goal){
if(!judgmentExists(goal[0])){
if(goal.length==3){
if(goal[1].equals("必修")&&(goal[2].equals("考察")||goal[2].equals("实验"))){
System.out.println(goal[0]+" : course type & access mode mismatch");
}else{
if(goal[1].equals("实验")&&goal[2].equals("实验")){
Course course=new Course(goal[0],goal[1],goal[2]);
courses.add(course);
} else if(goal[2].equals("考试")||goal[2].equals("考察")){
Course course=new Course(goal[0],goal[1],goal[2]);
courses.add(course);
}else{
pri();
}
}
}
else if (goal[1].equals("必修")){
Course course=new Course(goal[0],goal[1],"考试");
courses.add(course);
}else {
pri();
}
}
}
void A(){
if(goal.length==5){
regularGrade= Double.parseDouble(goal[3]);
finalGrade= Double.parseDouble(goal[4]);
}else if(goal.length==4){
finalGrade= Double.parseDouble(goal[3]);
}
}
void B(){
course1=findCourse(goal[2]);
int index=courses.indexOf(course1);
if(goal.length>=8){
studentCourse=new StudentCourse(course1.getCourseName(),course1.getCourseNature(),course1.getAssessmentMode());
for(int i=4;i<goal.length;i++){
if(goal[i].matches(patternGrade)){
courses.get(index).getGradeList().add(Double.valueOf(goal[i]));
studentCourse.getGradeList().add(Double.valueOf(goal[i]));
}
}
courses.get(index).setFlog(courses.get(index).getFlog()+1);
}else{
courses.get(index).setRegularGrade((int) (courses.get(index).getRegularGrade()+regularGrade));
courses.get(index).setFinalGrade((int) (courses.get(index).getFinalGrade()+finalGrade));
courses.get(index).setGradeAverage((int) (courses.get(index).getGradeAverage()+(int)(regularGrade*0.3+finalGrade*0.7)));
courses.get(index).setFlog(courses.get(index).getFlog()+1);
studentCourse=new StudentCourse(course1.getCourseName(),course1.getCourseNature(),course1.getAssessmentMode(),regularGrade,finalGrade);
}
}
void addA(){
A();
B();
student=new Student(goal[0],goal[1]);
student.getStudentCourses().add(studentCourse);
cla.getStudents().add(student);
classes.add(cla);
}
void addB(int index){
A();
B();
student=new Student(goal[0],goal[1]);
student.getStudentCourses().add(studentCourse);
this.classes.get(index).getStudents().add(student);
}
void addC(int index,int index1){
A();
int f=0;
for(StudentCourse sc:this.classes.get(index).getStudents().get(index1).getStudentCourses()){
if(goal[2].equals(sc.getCourseName())){
f++;
}
}
if(f==0){
B();
this.classes.get(index).getStudents().get(index1).getStudentCourses().add(studentCourse);
}
}
void enteTheCourseGrade(String[]goal){
String classNumber = goal[0].substring(0, 6);
cla=new Class(classNumber);
student=new Student(goal[0],goal[1]);
if(!judgeStudent(goal[0])){
if(!judgeClass(classNumber)){
if(!judgmentExists(goal[2])){
cla.getStudents().add(student);
classes.add(cla);
System.out.println(goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if((course.getAssessmentMode().equals("考察")&&goal.length==5)||(course.getAssessmentMode().equals("考试")&&goal.length<5)||(goal.length>5&&(goal.length<8||goal.length<Integer.parseInt(goal[3]) + 4))){
cla.getStudents().add(student);
classes.add(cla);
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addA();
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addA();
} else if (course.getAssessmentMode().equals("实验")&&(goal.length>=8&&goal.length==Integer.parseInt(goal[3]) + 4)) {
int flog=0;
for(int i=4;i<goal.length;i++){
if(!goal[i].matches(patternGrade)){
flog=1;
break;
}
}
if(flog==0){
addA();
}else {
pri();
}
}
}
} else if (judgeClass(classNumber)) {
cla=findClass(classNumber);
int index=classes.indexOf(cla);
if(!judgmentExists(goal[2])){
this.classes.get(index).getStudents().add(student);
System.out.println(goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if((course.getAssessmentMode().equals("考察")&&goal.length==5)||(course.getAssessmentMode().equals("考试")&&goal.length<5)||(course.getAssessmentMode().equals("实验")&&(goal.length<8||goal.length<Integer.parseInt(goal[3]) + 4))){
this.classes.get(index).getStudents().add(student);
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addB(index);
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addB(index);
}else if (course.getAssessmentMode().equals("实验")&&(goal.length>=8&&goal.length==Integer.parseInt(goal[3]) + 4)) {
int flog=0;
for(int i=4;i<goal.length;i++){
if(!goal[i].matches(patternGrade)){
flog=1;
break;
}
}
if(flog==0){
addB(index);
}else {
pri();
}
}
}
}
} else {
student=findStudent(goal[0]);
cla=findClass(classNumber);
int index=classes.indexOf(cla);
int index1=classes.get(index).getStudents().indexOf(student);
if(!judgmentExists(goal[2])){
System.out.println(goal[0]+" "+goal[1]+" :"+goal[2]+" does not exist");
}else{
Course course=findCourse(goal[2]);
if((course.getAssessmentMode().equals("考察")&&goal.length==5)||(course.getAssessmentMode().equals("考试")&&goal.length<5)||(course.getAssessmentMode().equals("实验")&&(goal.length<8||goal.length<Integer.parseInt(goal[3]) + 4))){
this.classes.get(index).getStudents().add(student);
System.out.println(goal[0]+" "+goal[1]+" "+": access mode mismatch");
}else if(!course.getAssessmentMode().equals("考察")&&goal.length==5){
addB(index);
} else if (course.getAssessmentMode().equals("考察")&&goal.length==4) {
addB(index);
}else if (course.getAssessmentMode().equals("实验")&&(goal.length>=8&&goal.length==Integer.parseInt(goal[3]) + 4)) {
int flog=0;
for(int i=4;i<goal.length;i++){
if(!goal[i].matches(patternGrade)){
flog=1;
break;
}
}
if(flog==0){
addB(index);
}else {
pri();
}
}
}
}
}
void outputStudentGrades(){
Collections.sort(classes);
for (Class clazz : classes) {
clazz.sortStudentsByStudentId();
clazz.printStudentsByStudentId();
}
}
void outputCourseGrades(){
Collator collator = Collator.getInstance(Locale.CHINA);
Comparator<Course> courseComparator = Comparator.comparing(c -> c.getCourseName(), collator);
Collections.sort(courses, courseComparator);
for(Course course:courses){
course.printGradeAverage();
}
}
void outPutTheTotalCourseGradeOfTheClass(){
Collections.sort(classes);
for (Class clazz : classes) {
clazz.calculateGrade();
}
}
boolean judgmentExists(String goal){
for(Course course:courses) {
if (goal.equals(course.getCourseName())) {
return true;
}
}
if(courses.size()==0){
return false;
}
return false;
}
Course findCourse(String goal){
for(Course course:courses) {
if (goal.equals(course.getCourseName())) {
return course;
}
}
return null;
}
boolean judgeClass(String goal){
for(Class cla:classes){
if(cla.getClassNumber().equals(goal)){
return true;
}
}
if (classes.size()==0){
return false;
}
return false;
}
Class findClass(String goal){
for(Class cla:classes){
if(cla.getClassNumber().equals(goal)){
return cla;
}
}
return null;
}
boolean judgeStudent(String goal){
for(Class cla:classes){
for(Student student:cla.getStudents()){
if(student.getStudentId().equals(goal)){
return true;
}
}
if(cla.getStudents().size()==0){
return false;
}
}
if(classes.size()==0){
return false;
}
return false;
}
Student findStudent(String goal){
for(Class cla:classes){
for(Student student:cla.getStudents()){
if(student.getStudentId().equals(goal)){
return student;
}
}
}
return null;
}
}
class Course implements Comparable<Course>{
private String courseName;
private String courseNature;
private String assessmentMode;
private int regularGrade;
private int finalGrade;
private int flog=0;
private int gradeAverage=0;
public void setGradeAverage(int gradeAverage) {
this.gradeAverage = gradeAverage;
}
private List<Double>gradeList=new ArrayList<>();
public Course(String courseName, String courseNature, String assessmentMode) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMode = assessmentMode;
}
public void calculate(){
if(flog!=0){
if (this.courseNature.equals("必修")){
this.gradeAverage=this.gradeAverage/flog;
}else if(this.courseNature.equals("选修")){
if(this.assessmentMode.equals("考试")){
this.gradeAverage= (int) (this.regularGrade*0.3+this.finalGrade*0.7/flog);
}else if(this.assessmentMode.equals("考察")){
this.gradeAverage= this.finalGrade/flog;
}
}else if(this.courseNature.equals("实验")){
for (Double dou:gradeList) {
this.gradeAverage+=dou;
}
this.gradeAverage/=gradeList.size();
}
}
}
public void printGradeAverage(){
if(this.getAssessmentMode().equals("考察")){
calculate();
if(this.gradeAverage!=0){
System.out.println(this.getCourseName()+" "+this.getFinalGrade()/flog+" "+this.getGradeAverage());
}else{
System.out.println(this.getCourseName()+" "+"has no grades yet");
}
}else if(this.getAssessmentMode().equals("考试")){
calculate();
if(this.gradeAverage!=0){
System.out.println(this.getCourseName()+" "+this.getRegularGrade()/flog+" "+this.getFinalGrade()/flog+" "+this.getGradeAverage());
}else{
System.out.println(this.getCourseName()+" "+"has no grades yet");
}
}else{
calculate();
if(this.gradeAverage!=0){
System.out.println(this.getCourseName()+" "+this.getGradeAverage());
}else{
System.out.println(this.getCourseName()+" "+"has no grades yet");
}
}
}
public List<Double> getGradeList() {
return gradeList;
}
public void setGradeList(List<Double> gradeList) {
this.gradeList = gradeList;
}
public String getCourseName() {
return courseName;
}
public String getCourseNature() {
return courseNature;
}
public String getAssessmentMode() {
return assessmentMode;
}
public int getRegularGrade() {
return regularGrade;
}
public void setRegularGrade(int regularGrade) {
this.regularGrade = regularGrade;
}
public int getFinalGrade() {
return finalGrade;
}
public void setFinalGrade(int finalGrade) {
this.finalGrade = finalGrade;
}
public int getFlog() {
return flog;
}
public void setFlog(int flog) {
this.flog = flog;
}
public int getGradeAverage() {
return gradeAverage;
}
@Override
public int compareTo(Course otherCourse) {
return getCourseName().compareTo(otherCourse.getCourseName());
}
}
class Class implements Comparable<Class>{
private String classNumber;
private List<Student> students=new ArrayList<>();
private List<Course> courses=new ArrayList<>();
private int classGradeAverage=0;
public void calculateGrade(){
for(Student student:students){
this.classGradeAverage=this.classGradeAverage+student.getOverallGradeAverage();
}
this.classGradeAverage=this.classGradeAverage/students.size();
if(this.getClassGradeAverage()==0){
System.out.println((this.getClassNumber()+" "+"has no grades yet").trim());
}else {
System.out.println((this.getClassNumber()+" "+this.getClassGradeAverage()).trim());
}
}
public Class(String classNumber) {
this.classNumber = classNumber;
}
public void sortStudentsByStudentId() {
Collections.sort(students);
}
public void printStudentsByStudentId() {
for (Student student : students) {
student.OverallGradeAverage();
if(student.getOverallGradeAverage()==0){
System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+"did not take any exams");
}else{
System.out.println(student.getStudentId()+" "+student.getStudentName()+" "+student.getOverallGradeAverage());
}
}
}
@Override
public int compareTo(Class other) {
return this.classNumber.compareTo(other.getClassNumber());
}
public String getClassNumber() {
return classNumber;
}
public List<Student> getStudents() {
return students;
}
public int getClassGradeAverage() {
return classGradeAverage;
}
}
class Student implements Comparable<Student>{
private String studentId;
private String studentName;
private List<StudentCourse>studentCourses=new ArrayList<>();
private int overallGradeAverage=0;
public Student(String studentId, String studentName) {
this.studentId = studentId;
this.studentName = studentName;
}
public String getStudentId() {
return studentId;
}
public String getStudentName() {
return studentName;
}
public List<StudentCourse> getStudentCourses() {
return studentCourses;
}
public int getOverallGradeAverage() {
return overallGradeAverage;
}
public void setOverallGradeAverage(int overallGradeAverage) {
this.overallGradeAverage = overallGradeAverage;
}
public void OverallGradeAverage(){
for(StudentCourse studentCourse:studentCourses){
studentCourse.calculate();
overallGradeAverage= (int) (overallGradeAverage+studentCourse.getGradeAverage());
}
if(studentCourses.size()!=0){
overallGradeAverage/=studentCourses.size();
}
setOverallGradeAverage(overallGradeAverage);
}
@Override
public int compareTo(Student other) {
return this.studentId.compareTo(other.getStudentId());
}
}
class StudentCourse {
public String getCourseName() {
return courseName;
}
private String courseName;
private String courseNature;
private String assessmentMode;
private List<Double>gradeList=new ArrayList<>();
private double regularGrade;
private double finalGrade;
private double gradeAverage=0.0;
public StudentCourse(String courseName, String courseNature, String assessmentMode, double regularGrade,double finalGrade) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMode = assessmentMode;
this.regularGrade = regularGrade;
this.finalGrade = finalGrade;
}
public StudentCourse(String courseName, String courseNature, String assessmentMode) {
this.courseName = courseName;
this.courseNature = courseNature;
this.assessmentMode = assessmentMode;
this.gradeList = gradeList;
}
public List<Double> getGradeList() {
return gradeList;
}
public void setGradeList(List<Double> gradeList) {
this.gradeList = gradeList;
}
public double getGradeAverage() {
return gradeAverage;
}
public void calculate(){
if (this.courseNature.equals("必修")){
this.gradeAverage=(this.regularGrade*0.3+this.finalGrade*0.7);
}else if(this.courseNature.equals("选修")){
if(this.assessmentMode.equals("考试")){
this.gradeAverage=this.regularGrade*0.3+this.finalGrade*0.7;
}else if(this.assessmentMode.equals("考察")){
this.gradeAverage= (double) this.finalGrade;
}
}else if(this.courseNature.equals("实验")){
for (Double dou:gradeList) {
this.gradeAverage+=dou;
}
this.gradeAverage/=gradeList.size();
}
}
}
踩坑心得：一定要做好对整个题目的一个分析，先做什么在做什么，构建什么样的对象，用什么容器，如何筛选数据，如何存储数据。一定不要急着动手，不要看着测试点修改代码，不能面向结果编程。
第十二次题目集我几乎没拿到分就是因为自己筛选数据后数据错误的输出结果的先后顺序不同，或者明明是错误的数据却储存了起来而导致的错误。除了测试样例之外我一分没有拿到。一定要引以为戒。
改进建议：
对主方法中筛选数据的顺序进行一个修改，原先的筛选数据并不太符合题目要求和逻辑。存储数据的方式也用我在源码分析中提到的方式修改，可以减少许多代码量和复杂度。
如果可以的话减少容器的数量，不然自己写着写着都不知道自己该把数据放在哪个容器里。
按照题目要求，先把所有wrong format的情况筛选出来，再来根据其他情况进行一个筛选。
如果所有信息都没有错误就放在学生课程信息对象里。
总结：在10-16周里，学到了许多新的知识，lambda表达式，javafx，set，map，foreach等等知识点，并且随着习题的积累提高了编写代码的能力和效率。
课程客观评价和建议：我认为这门课程的教学理念以及教学方式都是正确的，可以做到学什么用什么，并且通过pta的作业也可以驱动自学。做到讲练结合
浙公网安备 33010602011771号