目录
1.前言
2.设计与分析
3.踩坑心得
4.改进建议
5.总结
1.前言
题目集8
课程成绩统计程序-1
题目集9
统计Java程序中关键词的出现次数
题目集10
容器-HashMap-检索
容器-HashMap-排序
课程成绩统计程序-2
动物发声模拟器（多态）
题目集11
容器-ArrayList-排序
课程成绩统计程序-3
jmu-Java-02基本语法-03-身份证排序 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack jmu-Java-03面向对象基础-05-覆盖 题目集8是比较简单的，我也完成了，但是我的代码超限，尽管我改了变量名，且把重复的地方也用方法代替了，但最后我代码还是不能全过，这是比较可惜的。 题目集9我感觉我自己写的代码没有问题，但就是过不了全部的测试点，测试点没有例子，找了许久也没试出来 题目集10其他问题我觉得简单，但是那道迭代问题的数据处理问题，没有啥思路，室友给了点方法，但我还是没有做出来，放弃了 题目集11的出现我是真没有想到，为什么还会有pta，18周我们有3次考试，2个节课作业，这次pta我也看了那个迭代题目，发现必须需要大改，没啥思路，时间全部投入到英语6级考试去了，星期6考完，晚上看了pta交了总人数，发现很多人没交，但也有人满分了，但是总体是不太行的，估计大家这星期都挺忙的。 2.设计与分析 课程成绩统计程序-1某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃
package 课程成绩统计系统3;
import java.text.Collator;
import java.util.*;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Select select = new Select();
ArrayList<SelectedCourse> selectedCourses= new ArrayList();
Pattern pattern = Pattern.compile("[0-9]*");
String[] s = in.nextLine().split(" ");
while (!s[0].equals("end") && !pattern.matcher(s[0]).matches()){
if((s.length == 3 || s.length == 4) && s[0].length() <= 10){
if((s[1].equals("必修")||s[1].equals("选修"))&&(s[2].equals("考试")||s[2].equals("考察"))){
if(!select.getCourse().contains(new Course(s[0],"","")))
if(!select.addCourse(s[0],s[1],s[2]))
System.out.println(s[0]+" : course type & access mode mismatch");
}
}
s = in.nextLine().split(" ");
}
while (!s[0].equals("end")){
if(s.length == 5 || s.length == 4){
SelectedCourse record = new SelectedCourse(new Course(s[2],"",""),new Student( Integer.parseInt(s[0]),""));
if (!selectedCourses.contains(record)) {
if (Integer.parseInt(s[3]) >= 0 && Integer.parseInt(s[3]) <= 100) {
if (s.length == 4) {
int judge = select.addCourseScore(s[2], -1, Integer.parseInt(s[3]));
if (judge == -1) {
System.out.println(s[2] + " does not exist");
} else if (judge == -2)
System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
select.addStudent(Integer.parseInt(s[0]), s[1], s[2], -1, Integer.parseInt(s[3]));
select.addClass(s[0]);
select.addClassStudent(s[0]);
} else if (s.length == 5 && Integer.parseInt(s[4]) >= 0 && Integer.parseInt(s[4]) <= 100) {
int judge = select.addCourseScore(s[2], Integer.parseInt(s[3]), Integer.parseInt(s[4]));
if (judge == -1)
System.out.println(s[2] + " does not exist");
else if (judge == -2)
System.out.println(s[0] + " " + s[1] + " : access mode mismatch");
else if (judge == 0)
//System.out.println("666");
selectedCourses.add(record);
//}
select.addStudent(Integer.parseInt(s[0]), s[1], s[2], Integer.parseInt(s[3]), Integer.parseInt(s[4]));
//System.out.println("6");
select.addClass(s[0]);
//System.out.println("55");
select.addClassStudent(s[0]);
}
}
}
}
s = in.nextLine().split(" ");
}
select.students.sort(Comparator.naturalOrder());
select.courses.sort(Comparator.naturalOrder());
select.classes.sort(Comparator.naturalOrder());
select.scorePrint();
}
}
class Select {
public ArrayList<Course> courses = new ArrayList<>();
public ArrayList<Student> students = new ArrayList<>();
public ArrayList<Class> classes = new ArrayList<>();
public ArrayList<Course> getCourse() {
return courses;
}
private Score score = new ExaminationGrades();
public boolean addCourse(String courseName, String courseNature, String assessmentMethod) {
if (courseName.length() > 10) {
System.out.println("wrong format");
return true;
}
if (findCourse(courseName) >= 0)
return true;
if (courseNature.equals("必修") && assessmentMethod.equals("考察"))
return false;
if (findCourse(courseName) == -1)
this.courses.add(new Course(courseName, courseNature, assessmentMethod));
return true;
}
//在courses中根据课程名寻找课程并返回下标
public int findCourse(String course) {
Course judge = new Course(course, "", "");
return courses.indexOf(judge);
}
public int addCourseScore(String courseName, int uScore, int fScore){
int index = findCourse(courseName);
if(index == -1){
return -1;
}
else{
Course replace = courses.get(index);
if(replace.getA5().equals("考试")){
if(uScore >= 0){
score = new ExaminationGrades(fScore,uScore);
replace.addFinalScore(fScore);
replace.addUsualScore(uScore);
}
else
return -2;
}
else{
if(uScore < 0){
score = new ExmineGrade(fScore);
replace.addFinalScore(fScore);
}
else
return -2;
}
replace.addTotalScore(score.getTotalScore());
courses.set(index, replace);
return 0;
}
}
public void addStudent(int xueHao, String name, String courseName, int uScore, int fScore){
int index = findStudent(xueHao);
if(index == -1)
this.students.add(new Student(xueHao, name));
if(courses.contains(new Course(courseName,"",""))) {
if(!(courses.get(findCourse(courseName)).getA3().equals("考试") && uScore == -1)){
if(!(courses.get(findCourse(courseName)).getA3().equals("考察") && uScore >= 0)){
if (courses.get(findCourse(courseName)).getA3().equals("考试"))
score = new ExaminationGrades(fScore, uScore);
else
score = new ExmineGrade(fScore);
index = findStudent(xueHao);
Student replace = students.get(index);
replace.addTotalScore(score.getTotalScore());
students.set(index, replace);
}
}
}
}
public int findStudent(int xueHao){
Student judge = new Student(xueHao,"");
return students.indexOf(judge);
}
public void addClass(String xueHao){
if(xueHao.length() == 8 && findClass(xueHao.substring(0,6)) == -1)
classes.add(new Class(xueHao.substring(0,6), 0));
}
public void addClassStudent(String xueHao){
int index = findClass(xueHao.substring(0,6));
Class replace = classes.get(index);
replace.addStudent(students.get(findStudent(Integer.parseInt(xueHao))));
classes.set(index, replace);
}
public int findClass(String classNum){
Class jugde = new Class(classNum, 0);
return classes.indexOf(jugde);
}
public void scorePrint() {
for (int i = 0; i < students.size(); i++)
students.get(i).scoreShow();
for (int i = 0; i < courses.size(); i++)
courses.get(i).scoreShow();
for (int i = 0; i < classes.size(); i++)
classes.get(i).scoreShow();
}
}
class Class implements Comparable<Class>{
private String d1;
private int d2;
private ArrayList<Student> students = new ArrayList<>();
public Class(String classNum, int averageScore) {
this.d1 = classNum;
this.d2 = averageScore;
}
public void addStudent(Student student){
students.add(student);
double score = 0.0;
for(int i = 0; i < students.size(); i++) {
score += students.get(i).getAverageScore();
}
//System.out.println(score);
this.d2 = (int)(score / students.size());
//System.out.println(d2);
}
public int getAverageScore() {
return d2;
}
public void scoreShow(){
//System.out.println(d2);
if(d2 == 0) {
//System.out.println("66");
System.out.println(d1 + " has no grades yet");
}
else {
//System.out.println("66");
System.out.println(d1 + " " + d2);
}
}
public boolean equals(Object obj) {
Class c = (Class) obj;
return this.d1.equals(c.d1);
}
@Override
public int compareTo(Class o) {
if (this.d2 > o.d2)
return 1;
else if (this.d2< o.d2) {
return -1;
}
return 0;
}
}
class Course implements Comparable<Course>{
private String a1, a3, a5;
private ArrayList<Integer> finalScores = new ArrayList<>();
private ArrayList<Integer> usualScores = new ArrayList<>();
private ArrayList<Double> totalScores = new ArrayList<>();
public Course(String courseName, String courseNature, String assessmentMethod) {
this.a1 = courseName;
this.a3 = courseNature;
this.a5 = assessmentMethod;
}
public String getA1() {
return a1;
}
public String getA3() {
return a3;
}
public String getA5() {
return a5;
}
public void addFinalScore(int score) {
finalScores.add(score);
}
public void addUsualScore(int score) {
usualScores.add(score);
}
public void addTotalScore(double score) {
totalScores.add(score);
}
public int getAverageFinal() {
double score = 0.0;
for (int i = 0; i < finalScores.size(); i++)
score += finalScores.get(i);
return (int) (score / finalScores.size());
}
public int getAverageUsual() {
double score = 0.0;
for (int i = 0; i < usualScores.size(); i++)
score += usualScores.get(i);
return (int) (score / usualScores.size());
}
public int getAverageTotal() {
double score = 0.0;
for (int i = 0; i < totalScores.size(); i++)
score += totalScores.get(i);
return (int) (score / totalScores.size());
}
public void scoreShow(){
//System.out.println(a3);
if(totalScores.isEmpty())
System.out.println(a1 +" has no grades yet");
else{
if(a5.equals("考试")) {
//System.out.println("555");
System.out.println(a1 + " " + getAverageUsual() + " " + getAverageFinal() + " " + getAverageTotal());
}
else {
//System.out.println("666");
System.out.println(a1 + " " + getAverageFinal() + " " + getAverageTotal());
}
}
}
@Override
public boolean equals(Object obj) {
Course c = (Course) obj;
return this.a1.equals(c.a1);
}
@Override
public int compareTo(Course o) {
if(this.getAverageTotal() > o.getAverageTotal())
return -1;
else if (this.getAverageTotal() < o.getAverageTotal()) {
return 1;
}
return 0;
}
}
class ExaminationGrades extends Score {
public ExaminationGrades() {
}
public ExaminationGrades(int finalCourse) {
super(finalCourse);
}
public ExaminationGrades(int finalCourse, int usualCourse) {
super(finalCourse, usualCourse);
}
@Override
public double getTotalScore() {
return b1 * 0.7 + b2 * 0.3;
}
}
class ExmineGrade extends Score {
public ExmineGrade() {
}
public ExmineGrade(int finalCourse) {
super(finalCourse);
}
@Override
public double getTotalScore() {
return b1;
}
}
abstract class Score {
protected int b1 = 0, b2 = 0;
public Score() {
}
public Score(int finalCourse) {
this.b1 = finalCourse;
}
public Score(int finalCourse, int usualCourse) {
this.b1 = finalCourse;
this.b2 = usualCourse;
}
public abstract double getTotalScore();
}
class Student implements Comparable<Student>{
private int c1;
private String c2;
private ArrayList<Double> totalScores = new ArrayList<>();
public Student(int xueHao, String name) {
this.c1 = xueHao;
this.c2 = name;
}
public int getXueHao() {
return c1;
}
public int getAverageScore() {
double score = 0.0;
for(int i = 0; i < totalScores.size(); i++)
score += totalScores.get(i);
if(totalScores.size() == 0)
return 0;
else
return (int)(score / totalScores.size());
}
public void addTotalScore(double score){
totalScores.add(score);
}
public void scoreShow(){
if(totalScores.isEmpty())
System.out.println(c1+" "+c2+" did not take any exams");
else
System.out.println(c1+" "+c2+" "+getAverageScore());
}
@Override
public boolean equals(Object obj) {
Student s = (Student)obj;
if(this.c1 == s.c1)
return true;
else
return false;
}
@Override
public int compareTo(Student o) {
if(this.getXueHao() > o.getXueHao())
return 1;
else if (this.getXueHao() < o.getXueHao()) {
return -1;
}
return 0;
}
}
class SelectedCourse {
public Course course;
public Student student;
public Score score;
public SelectedCourse(Course course, Student student) {
this.course = course;
this.student = student;
this.score = new ExaminationGrades();
}
public Course getCourse() {
return course;
}
public Student getStudent() {
return student;
}
public boolean equals(Object obj) {
SelectedCourse sc = (SelectedCourse) obj;
if(this.course.getA1().equals(sc.getCourse().getA1())&&this.student.getXueHao() == sc.getStudent().getXueHao())
return true;
else
return false;
}
}
这次题目我觉得难度适中，可以。室友使用数组做的，我也尝试用，写到匹配分数时，我发现需要写方法来匹配，个人觉得很难。所以我最后使用了list集合，挺方便的。
统计Java程序中关键词的出现次数
编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：
- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法
输入格式:
输入Java源码字符串，可以一行或多行，以exit行作为结束标志
输出格式:
- 当未输入源码时，程序输出
Wrong Format - 当没有统计数据时，输出为空
- 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为
数量\t关键字
import java.util.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String[] s ={"abstract","assert","boolean","break","byte","case","catch", "char","class","const","continue","default","do","double","else", "enum","extends","false","final","finally","float", "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"};
int i = 0;
StringBuilder stringbuilder = new StringBuilder();
Map map =new HashMap();
String a = in.nextLine();
int flag = 0,j;
while (!a.equals("exit")){
stringbuilder.append(a.replaceAll("//.*", " ").replaceAll("\".*\"", " ").replaceAll("\\[", " ").replaceAll("\\]", " ").replaceAll("\\,", " ").replaceAll("\\{"," ").replaceAll("\\}"," ").replaceAll("\\("," ").replaceAll("\\)"," ").replaceAll("\\;"," "));
a = in.nextLine();
flag=1;
}
if(flag == 0) {
System.out.println("Wrong Format");
}
String b = stringbuilder.toString().replaceAll("/\\*\\s*.*\\s*\\*/", " ").replaceAll("\\[", "").replaceAll("\\,","").replaceAll("\\]", "");
for(i=0;i< s.length;i++) {
Pattern pattern = Pattern.compile("\\b"+s[i]+"\\b");
Matcher matcher = pattern.matcher(b);
j = 0;
while(matcher.find()) {
j ++ ;
}
if(j!=0){
map.put(s[i], j);
}
}
Set set = map.keySet();
Object[] arr = set.toArray();
Arrays.sort(arr);
for (Object k : arr) {
System.out.println(map.get(k) + "\t" + k);
}
}
}
我思路还是看了课才了解，stringbulider的用法，让后我在这道题实现了stringbuilder中的方法，例如append与tostring，replaceall，replace。我觉的没有问题，因为我是根据题目要求来写的，一开始我只有删除注释与字符串的想法，先处理一行，再拼接这行字符串。最后我再处理数据，然后就过了大部分测试点，一部分测试点没有过，看完测试结果，我发现要去除那些符号，我以为是这里的问题，然后我不断加上去，还尝试多种方式，但最后好像不是这里的问题。后遗憾没得全分。
容器-HashMap-检索
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
使用HashMap存储学生信息，并实现根据学号的检索功能
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
end之后输入某个学号，执行程序输出该生的详细信息
输出格式:
输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩
如果没有查询到，则输出："The student "+查询的学号+" does not exist"
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Map<String,Student> map = new HashMap<>();
Scanner in = new Scanner(System.in);
String a = in.nextLine();
while (!a.equals("end")){
String[] b = a.split(" ");
Student student = new Student(b[1],Integer.parseInt(b[2]));
map.put(b[0],student);
a = in.nextLine();
}
String c = in.nextLine();
Set<Map.Entry<String,Student>>set = map.entrySet();
boolean flag = false;
for (Map.Entry<String,Student> entry: set){
Student student1 = map.get(entry);
if (c.equals(entry.getKey())) {
flag =true;
System.out.println(c + " " + entry.getValue().getName() + " " + entry.getValue().getScore());
}
}
if(flag == false){
System.out.println("The student "+ c+" does not exist");
}
}
}
class Student{
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}
这里我觉的很简单。不过多解释。
容器-HashMap-排序
输入多个学生的成绩信息，包括：学号、姓名、成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用HashMap存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩
以“end”为输入结束标志
输出格式:
按学号从大到小的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+成绩
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<Integer, Student> map = new HashMap<>();
Scanner in = new Scanner(System.in);
String a = in.nextLine();
while (!a.equals("end")){
String[] b = a.split(" ");
Student student = new Student(b[1],Integer.parseInt(b[2]));
map.put(Integer.valueOf(b[0]),student);
a = in.nextLine();
}
ArrayList<Integer>list = new ArrayList<>(map.keySet());
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1>o2?-1:1;
}
});
Iterator<Integer>iterator = list.iterator();
while ((iterator.hasNext())){
Integer key = iterator.next();
Student student = map.get(key);
System.out.println(key +" "+ student.getName() + " "+ student.getScore());
}
}
}
class Student{
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
}
课程成绩统计程序-2
课程成绩统计程序-2在第一次的基础上增加了实验课，以下加粗字体显示为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩的平均分
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
实验次数至少4次，不超过9次
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
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）成绩平均分只取整数部分，小数部分丢弃
这道题我最后没写出来，我展示我写的代码，但是没有过测试点
package 课程成绩统计系统6;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
GradeData gradeData = new GradeData();
ArrayList<SelectedCourse> selectedCourses= new ArrayList<>();
Pattern pattern = Pattern.compile("[0-9]*");
String[] command = in.nextLine().split(" ");
while (!command[0].equals("end") && !pattern.matcher(command[0]).matches()){
if((command.length == 3 || command.length == 4) && command[0].length() <= 10){
if((command[1].equals("必修")||command[1].equals("选修"))&&(command[2].equals("考试")||command[2].equals("考察"))){
if(!gradeData.getCourse().contains(new Course(command[0],"","")))
if(!gradeData.addCourse(command[0],command[1],command[2]))
System.out.println(command[0]+" : course type & access mode mismatch");
}
else
System.out.println("wrong format");
}
else
System.out.println("wrong format");
command = in.nextLine().split(" ");
}
while (!command[0].equals("end")){
if(command.length>=4) {
SelectedCourse record = new SelectedCourse(command);
if (record.judge()) {
if (!selectedCourses.contains(record)) {
if (command.length == 4) {
int judge = gradeData.addCourseScore(command[2], -1, Integer.parseInt(command[3]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent(Integer.parseInt(command[0]), command[1], command[2], -1, Integer.parseInt(command[3]));
gradeData.addClass(command[0]);
}
if (command.length == 5) {
int judge = gradeData.addCourseScore(command[2], Integer.parseInt(command[3]), Integer.parseInt(command[4]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[3]), Integer.parseInt(command[4]));
gradeData.addClass(command[0]);
}
if(command.length == 8){
String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]));
gradeData.addClass(command[0]);
}
if(command.length == 9){
//String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]));
gradeData.addClass(command[0]);
}
if(command.length == 10){
String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]));
gradeData.addClass(command[0]);
}
if(command.length == 11){
String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]));
gradeData.addClass(command[0]);
}
if(command.length == 12){
String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]));
gradeData.addClass(command[0]);
}if(command.length == 13){
String[] b = new String[]{command[4],command[5],command[6],command[7]};
//b.length = 0;
//b.length = command.length-4;
int judge = gradeData.addCourseScore1(command[2],Integer.parseInt(command[4]),Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]),Integer.parseInt(command[12]));
if (judge == -1)
System.out.println(command[2] + " does not exist");
else if (judge == -2)
System.out.println(command[0] + " " + command[1] + " : access mode mismatch");
else if (judge == 0)
selectedCourses.add(record);
gradeData.addStudent1(Integer.parseInt(command[0]), command[1], command[2], Integer.parseInt(command[4]), Integer.parseInt(command[5]),Integer.parseInt(command[6]),Integer.parseInt(command[7]),Integer.parseInt(command[8]),Integer.parseInt(command[9]),Integer.parseInt(command[10]),Integer.parseInt(command[11]),Integer.parseInt(command[12]));
gradeData.addClass(command[0]);
}
}
} else
System.out.println("wrong format");
}
else
System.out.println("wrong format");
command = in.nextLine().split(" ");
}
gradeData.students.sort(Comparator.naturalOrder());
gradeData.courses.sort(Comparator.naturalOrder());
gradeData.classes.sort(Comparator.naturalOrder());
gradeData.scorePrint();
}
}
class GradeData {
ArrayList<Course> courses = new ArrayList<>();
ArrayList<Student> students = new ArrayList<>();
ArrayList<Class> classes = new ArrayList<>();
Score score = new ExamScore(0,0);
public GradeData() {
}
public ArrayList<Course> getCourse() {
return courses;
}
//添加课程信息
public boolean addCourse(String course, String property, String form){
if(course.length() > 10){
System.out.println("wrong format");
return true;
}
if(findCourse(course) >= 0)
return true;
if(property.equals("必修") && form.equals("考察")||(property.equals("实验")&&(!form.equals("实验"))))
return false;
if(findCourse(course) == -1)
this.courses.add(new Course(course, property, form));
return true;
}
public int addCourseScore(String course, int uScore, int fScore){
int index = findCourse(course);
if(index == -1){
return -1;
}
else{
Course replace = courses.get(index);
if(replace.getForm().equals("考试")){
if(uScore >= 0){
score = new ExamScore(fScore,uScore);
replace.addFinalScore(fScore);
replace.addUsualScore(uScore);
}
else
return -2;
}
else{
if(uScore < 0){
score = new ResearchSourse(fScore);
replace.addFinalScore(fScore);
}
else
return -2;
}
replace.addTotalScore(score.getTotalScore());
courses.set(index, replace);
return 0;
}
}
public int addCourseScore1(String course,int...scores){
int index = findCourse(course);
if(index == -1){
return -1;
}
else{
Course replace = courses.get(index);
if(replace.getForm().equals("实验")){
int i = 0;
if(scores[i] >= 0){
score = new Experimentgrades(scores);
replace.addExperimentScore(scores);
}
else
return -2;
}
replace.addTotalScore(score.getTotalScore());
courses.set(index, replace);
return 0;
}
}
public int findCourse(String course){
Course judge = new Course(course,"","");
return courses.indexOf(judge);
}
public void addStudent(int stuID, String name, String course, int uScore, int fScore){
int index = findStudent(stuID);
if(index == -1)
this.students.add(new Student(name, stuID));
if(courses.contains(new Course(course,"",""))) {
if(!(courses.get(findCourse(course)).getForm().equals("考试") && uScore == -1)){
if(!(courses.get(findCourse(course)).getForm().equals("考察") && uScore >= 0)){
if (courses.get(findCourse(course)).getForm().equals("考试"))
score = new ExamScore(fScore, uScore);
else
score = new ResearchSourse(fScore);
index = findStudent(stuID);
Student replace = students.get(index);
replace.addTotalScore(score.getTotalScore());
students.set(index, replace);
}
}
}
}
public void addStudent1(int stuID, String name, String course,int...scores){
int index = findStudent(stuID);
if(index == -1)
this.students.add(new Student(name, stuID));
if(courses.contains(new Course(course,"",""))) {
if((courses.get(findCourse(course)).getForm().equals("实验") )){
score = new Experimentgrades(scores);
index = findStudent(stuID);
Student replace = students.get(index);
replace.addTotalScore(score.getTotalScore());
students.set(index, replace);
}
}
}
public int findStudent(int stuID){
Student judge = new Student("", stuID);
return students.indexOf(judge);
}
public void addClass(String stuID){
if(stuID.length() == 8 && findClass(stuID.substring(0,6)) == -1)
classes.add(new Class(stuID.substring(0,6), -1));
int index = findClass(stuID.substring(0,6));
if(!students.get(findStudent(Integer.parseInt(stuID))).getTotalScores().isEmpty()){
Class replace = classes.get(index);
replace.addStudent(students.get(findStudent(Integer.parseInt(stuID))));
classes.set(index, replace);
}
}
public int findClass(String classNum){
Class jugde = new Class(classNum, -1);
return classes.indexOf(jugde);
}
public void scorePrint(){
for (int i = 0; i < students.size(); i++)
students.get(i).scoreShow();
for (int i = 0; i < courses.size(); i++)
courses.get(i).scoreShow();
for (int i = 0; i < classes.size(); i++)
classes.get(i).scoreShow();
}
}
class SelectedCourse {
public Course course;
public Student student;
public String[] command;
public SelectedCourse(String[] command) {
this.course = new Course(command[2],"","");
this.student = new Student("",Integer.parseInt(command[0]));
this.command = command;
}
public boolean judge(){
Pattern pattern = Pattern.compile("0|[0-9]{1,2}|100");
if(command[0].length() == 8 && command[1].length() <= 10){
//if(command[2].equals(course.getCourse())&&(course.getForm().equals("实验"))&&(Integer.parseInt(command[3])>3||Integer.parseInt(command[3])<10)){
//System.out.println();
//}
//else {
if (pattern.matcher(command[3]).matches()) {
if (command.length == 4) {
return true;
} else if (pattern.matcher(command[4]).matches()) {
return true;
} else
return false;
} else
return false;
//}
}
else
return false;
}
public Course getCourse() {
return course;
}
public Student getStudent() {
return student;
}
@Override
public boolean equals(Object obj) {
SelectedCourse sc = (SelectedCourse) obj;
if(this.course.getCourse().equals(sc.getCourse().getCourse())&&this.student.getStuID() == sc.getStudent().getStuID())
return true;
else
return false;
}
}
class Class implements Comparable<Class>{
private String classNum;
private int averageScore;
private ArrayList<Student> students = new ArrayList<>();
public Class(String classNum, int averageScore) {
this.classNum = classNum;
this.averageScore = averageScore;
}
public void addStudent(Student student){
students.add(student);
double score = 0.0;
for(int i = 0; i < students.size(); i++)
score += students.get(i).getAverageScore();
this.averageScore = (int)(score / students.size());
}
public int getAverageScore() {
return averageScore;
}
public void scoreShow(){
if(students.isEmpty())
System.out.println(classNum+" has no grades yet");
else
System.out.println(classNum+" "+averageScore);
}
@Override
public boolean equals(Object obj) {
Class c = (Class) obj;
return this.classNum.equals(c.classNum);
}
@Override
public int compareTo(Class o) {
if (this.averageScore> o.averageScore)
return 1;
else if (this.averageScore< o.averageScore) {
return -1;
}
return 0;
}
}
class Student implements Comparable<Student>{
private String name;
private int stuID;
private ArrayList<Double> totalScores = new ArrayList<>();
public Student(String name, int stuID) {
this.name = name;
this.stuID = stuID;
}
public ArrayList<Double> getTotalScores() {
return totalScores;
}
public int getStuID() {
return stuID;
}
public void addTotalScore(double score){
totalScores.add(score);
}
public int getAverageScore() {
double score = 0.0;
for(int i = 0; i < totalScores.size(); i++)
score += totalScores.get(i);
if(totalScores.size() == 0)
return 0;
else
return (int)(score / totalScores.size());
}
public void scoreShow(){
if(totalScores.isEmpty())
System.out.println(stuID+" "+name+" did not take any exams");
else
System.out.println(stuID+" "+name+" "+getAverageScore());
}
@Override
public boolean equals(Object obj) {
Student s = (Student)obj;
if(this.stuID == s.stuID)
return true;
else
return false;
}
@Override
public int compareTo(Student o) {
if(this.getStuID() > o.getStuID())
return 1;
else if (this.getStuID() < o.getStuID()) {
return -1;
}
return 0;
}
}
class Course implements Comparable<Course>{
private String course;
private String property;
private String form;
private ArrayList<Integer> finalScores = new ArrayList<>();
private ArrayList<Integer> usualScores = new ArrayList<>();
private ArrayList<Double> totalScores = new ArrayList<>();
public Course(String course, String property, String form) {
this.course = course;
this.form = form;
this.property = property;
}
public String getCourse() {
return course;
}
public String getForm() {
return form;
}
public void addFinalScore(int score){
finalScores.add(score);
}
public void addUsualScore(int score){
usualScores.add(score);
}
public void addExperimentScore( int...scores){
int total = 0;
int i = 0;
for(int grade:scores)
{
total += grade;
i++;
}
totalScores.add((double) total);
}
//public void addShiyan(int...score){
//}
public void addTotalScore(double score){
totalScores.add(score);
}
public int getAverageFinal(){
double score = 0.0;
for(int i = 0; i < finalScores.size(); i++)
score += finalScores.get(i);
return (int)(score / finalScores.size());
}
public int getAverageUsual(){
double score = 0.0;
for(int i = 0; i < usualScores.size(); i++)
score += usualScores.get(i);
return (int)(score / usualScores.size());
}
public int getAverageTotal(){
double score = 0.0;
for(int i = 0; i < totalScores.size(); i++)
score += totalScores.get(i);
return (int)(score / totalScores.size());
}
public void scoreShow(){
if(totalScores.isEmpty())
System.out.println(course+" has no grades yet");
else{
if(form.equals("考试"))
System.out.println(course+" "+getAverageUsual()+" "+getAverageFinal()+" "+getAverageTotal());
else if(form.equals("考察"))
System.out.println(course+" "+getAverageFinal()+" "+getAverageTotal());
else if (form.equals("实验")) {
System.out.println(course + " "+ getAverageTotal());
}
}
}
@Override
public boolean equals(Object obj) {
Course c = (Course) obj;
return this.course.equals(c.course);
}
@Override
public int compareTo(Course o) {
if(this.getAverageTotal() > o.getAverageTotal())
return -1;
else if (this.getAverageTotal() < o.getAverageTotal()) {
return 1;
}
return 0;
}
}
abstract class Score {
protected int finalScore = 0;
protected int usualScore = 0;
ArrayList<Integer>arrayList = new ArrayList<>();
public Score() {
}
public Score(int finalCourse) {
this.finalScore = finalCourse;
}
public Score(int finalCourse, int usualCourse) {
this.finalScore = finalCourse;
this.usualScore = usualCourse;
}
public Score(int finalScore, int usualScore, ArrayList<Integer> arrayList) {
this.finalScore = finalScore;
this.usualScore = usualScore;
this.arrayList = arrayList;
}
public abstract double getTotalScore();
}
class ExamScore extends Score{
public ExamScore(int finalCourse, int usualCourse) {
super(finalCourse, usualCourse);
}
@Override
public double getTotalScore(){
return finalScore * 0.7 + usualScore * 0.3;
}
}
class ResearchSourse extends Score{
public ResearchSourse(int finalCourse){
super(finalCourse);
}
@Override
public double getTotalScore(){
return finalScore;
}
}
class Experimentgrades extends Score{
int total = 0;
public Experimentgrades(int...scores){
int i= 0;
for(int grade:scores)
{
total += grade;
i++;
}
}
@Override
public double getTotalScore() {
return total;
}
}
这道题难就难在动态数据处理，传参时碰到的问题。我采用了死方法，穷举法（有缺陷），但是却没过测试点。
7-4 动物发声模拟器（多态） 分数 20 作者 刘凤良 单位 天津仁爱学院设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
请在下面的【】处添加代码。
//动物发生模拟器. 请在下面的【】处添加代码。 public class AnimalShoutTest2 { public static void main(String[] args) { Cat cat = new Cat(); Dog dog = new Dog(); Goat goat = new Goat(); speak(cat); speak(dog); speak(goat); } //定义静态方法speak() 【】 } //定义抽象类Animal 【】class Animal{ 【】 } //基于Animal类，定义猫类Cat，并重写两个抽象方法 class Cat 【】{ 【】 【】 } //基于Animal类，定义狗类Dog，并重写两个抽象方法 class Dog 【】{ 【】 【】 } //基于Animal类，定义山羊类Goat，并重写两个抽象方法 class Goat 【】{ 【】 【】 }
public class Main {
//动物发生模拟器. 请在下面的【】处添加代码。
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
private static void speak(Animal aniaml){
System.out.println(aniaml.getAnimalClass()+"的叫声"+"："+aniaml.shout());
}
}
//定义抽象类Animal
abstract class Animal{
abstract public String shout();
abstract public String getAnimalClass();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
@Override
public String shout() {
return "喵喵";
}
@Override
public String getAnimalClass() {
return "猫";
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
@Override
public String shout() {
return "汪汪";
}
@Override
public String getAnimalClass() {
return "狗";
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
@Override
public String shout() {
return "咩咩";
}
@Override
public String getAnimalClass() {
return "山羊";
}
}
这道题没啥难度，最简单的问题。
容器-ArrayList-排序
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
Scanner in = new Scanner(System.in);
String a = in.nextLine();
while (!a.equals("end")){
String[] b = a.split(" ");
Student student = new Student(b[0],b[1],Integer.parseInt(b[2]),Integer.parseInt(b[3]));
list.add(student);
a = in.nextLine();
}
Collections.sort(list);
for (Student student:list
) {
System.out.println(student.getId()+ " "+student.getName() + " " +student.getTotal());
}
}
}
class Student implements Comparable<Student>{
private String Id;
private String name;
private int chinese;
private int math;
public Student(String id, String name, int chinese, int math) {
Id = id;
this.name = name;
this.chinese = chinese;
this.math = math;
}
public String getId() {
return Id;
}
public void setId(String id) {
Id = id;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getTotal(){
return getChinese() + getMath();
}
@Override
public int compareTo(Student o) {
return o.getTotal() - this.getTotal();
}
}
课程成绩统计程序-3
课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，
要求：修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。
完成课程成绩统计程序-2、3两次程序后，比较继承和组合关系的区别。思考一下哪一种关系运用上更灵活，更能够适应变更。
题目最后的参考类图未做修改，大家根据要求自行调整，以下内容加粗字体显示的内容为本次新增的内容。
某高校课程从性质上分为：必修课、选修课、实验课，从考核方式上分为：考试、考察、实验。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
实验的总成绩等于课程每次实验成绩乘以权重后累加而得。
课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。实验课的成绩必须为实验。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。
考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重
考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重
实验次数至少4次，不超过9次
课程性质输入项：必修、选修、实验
考核方式输入选项：考试、考察、实验
考试/考查课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
考试/考查课程成绩信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
实验课程成绩信息包括：学号、姓名、课程名称、每次成绩｛在系列-2的基础上去掉了（实验次数），实验次数要和实验课程信息中输入的分项成绩数量保持一致｝
实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩
以上信息的相关约束：
1）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
2）学号由8位数字组成
3）姓名不超过10个字符
4）课程名称不超过10个字符
5）不特别输入班级信息，班级号是学号的前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）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
6）如果解析实验课程信息时，输入的分项成绩数量值和分项成绩权重的个数不匹配，输出：课程名称+" : number of scores does not match"
7）如果解析考试课、实验课时，分项成绩权重值的总和不等于1，输出：课程名称+" : weight value error"
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
jmu-Java-02基本语法-03-身份证排序
- 输入n，然后连续输入n个身份证号。
- 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
in.nextLine();
String[] b = new String[a];
String[]d = new String[a];
for (int i = 0; i < a; i++) {
b[i] = in.nextLine();
}
String c= in.nextLine();
for (;c.equals("sort1")||c.equals("sort2");){
if (c.equals("sort1")) {
for (int j = 0; j < a; j++) {
d[j] = b[j].substring(6, 10) + "-" + b[j].substring(10, 12) + "-" + b[j].substring(12, 14);
}
Arrays.sort(d);
for (int j = 0; j < a; j++) {
System.out.println(d[j]);
}
} else if (c.equals("sort2")) {
for (int j = 0; j < a; j++){
d[j] = b[j].substring(6,14);
}
Arrays.sort(d);
for (int j =0 ;j< a;j++) {
for(int i = 0;i < a;i++)
if(b[i].contains(d[j]))
System.out.println(b[i].toString());
}
}
System.out.println("exit");
c= in.nextLine();
}
}
}
jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:
public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek(); //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size(); //返回栈中元素个数
定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。
main方法说明
- 输入n，建立可包含n个元素的ArrayIntegerStack对象
- 输入m个值，均入栈。每次入栈均打印入栈返回结果。
- 输出栈顶元素，输出是否为空，输出size
- 使用Arrays.toString()输出内部数组中的值。
- 输入x，然后出栈x次，每次出栈均打印。
- 输出栈顶元素，输出是否为空，输出size
- 使用Arrays.toString()输出内部数组中的值
import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek(); //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size(); //返回栈中元素个数
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
ArrayIntegerStack arrayIntegerStack = new ArrayIntegerStack(a);
int m = in.nextInt();
for(int i=0;i<m;i++) {
int temp = in.nextInt();
System.out.println(arrayIntegerStack.push(temp));
}
System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
System.out.println(Arrays.toString(arrayIntegerStack.getA()));
int x = in.nextInt();
for(int j = 0;j<x;j++) {
System.out.println(arrayIntegerStack.pop());
}
System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
System.out.println(Arrays.toString(arrayIntegerStack.getA()));
}
}
class ArrayIntegerStack implements IntegerStack{
private Integer[] a;
private int number = 0; // 用于标记数组长度
public Integer[] getA() {
return a;
}
public void setA(Integer[] a) {
this.a = a;
}
public ArrayIntegerStack(int b){
a = new Integer[b];
number = 0;
}
@Override
public Integer push(Integer item) {
if(item==null) {
return null;
}
if(number==this.a.length) {
return null;
}
a[number++]=item;
return item;
}
@Override
public Integer pop() {
if(number==0) {
return null;
}
number--;
return a[number];
}
@Override
public Integer peek() {
if(number==0) {
return null;
}
return a[number-1];
}
@Override
public boolean empty() {
if(number==0) {
return true;
}
else {
return false;
}
}
@Override
public int size() {
return number;
}
}
jmu-Java-03面向对象基础-05-覆盖
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。
提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
import java.util.Objects;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n1 = in.nextInt();
PersonOverride[] personOverride =new PersonOverride[n1];
for(int i=0;i<n1;i++) {
personOverride[i] = new PersonOverride();
}
int n2 = in.nextInt();
PersonOverride[] personOverrides = new PersonOverride[n2];
int length = 0;
for(int i=0;i<n2;i++) {
String name = in.next();
int age = in.nextInt();
boolean gender = in.nextBoolean();
boolean flag = true;
PersonOverride personOverride1 = new PersonOverride(name, age, gender);
for (int j = 0; j < length; j++) {
if (personOverrides[j].equals(personOverride1)) {
flag = false;
break;
}
}
if (flag) {
personOverrides[length] = personOverride1;
length++;
}
}
for(PersonOverride personOverride2:personOverride) {
System.out.println(personOverride2);
}
for(int j=0;j<length;j++) {
System.out.println(personOverrides[j]);
}
System.out.println(length);
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
class PersonOverride {
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this("default",1,true);
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object o) {
if (this == o){
return true;
}
if(o == null)
{
return false;
}
if (this.getClass() != o.getClass()){
return false;
}
PersonOverride p = (PersonOverride) o;
return Objects.equals((this.name), p.name) && this.gender == p.gender && this.age==p.age;
}
}
按照它给的一步一步写，应该是不难的。
3.踩坑心得
题目集8，我觉的没啥问题，大部分的给的测试点都能过
这是我的类图，经过室友的指点我改善了代码，把比较方法，使用compartor接口来实现，非常好用。最后，是代码超限，拿不下较大分数。这是比较要注意改进的地方。
因为我删代码，删了那些错误输出，结果没过这些代码。
但是我测过那些代码，实际上是全部能过的。
题目集9
这里的正常测试我都试了几十遍了，但还是没有试出来为什么结果错了。还有那个方括号我也是测过了，不知道为什代码错了，现在我也还是不知道为什么。
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
HashMap<String,Integer> hashMap = new HashMap<>();
String[] s = { "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const","continue", "default", "do", "double", "else", "enum", "extends", "false", "final", "finally", "float", "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" };//关键词数组
int count = 0;
Scanner input = new Scanner(System.in);
String a = input.nextLine();
String b = "";
for(;!a.equals("exit");){//输入代码,拼接代码
b = b + "\n" + a;
a = input.nextLine();
}
if(b.isEmpty())//判断输入的代码是否为空int
System.out.println("Wrong Format");
else{
b = delete(b);
b = delete1(b);
b = delete2(b);
b = delte3(b);
b = delte4(b);
b = delte5(b);
}
for(int i = 0;i < s.length; i ++){//数量统计
Pattern pattern = Pattern.compile("\\b" + s[i] + "\\b");// 创建关键词的正则表达式
Matcher matcher = pattern.matcher(b);// 字符串与关键词匹配
count = 0;
while (matcher.find()) // 找到该关键词的话,记录该关键词的次数
count++;
if (count != 0)
hashMap.put(s[i], count);
}
Set set = hashMap.keySet();
Object[] arr = set.toArray();
Arrays.sort(arr);
for (Object k : arr) {
System.out.println(hashMap.get(k) + "\t" + k);
}
}
public static String delete(String b){//删除字符串的内容
String c = "\".*?\"";
String tmep = b.replaceAll(c," ");
return tmep;
}
public static String delete1(String b){//删除单行注释
String d = "//.*";
String tmep = b.replaceAll(d," ");
return tmep;
}
public static String delete2(String c){//删除多行注释
String e = "/\\*[\\s\\S]*?\\*///";
String tmep = c.replaceAll(e," ");
return tmep;
}
private static String delte3(String d) {
String f = "\\[" ;
String temp = d.replaceAll(f," ");
return temp;
}
private static String delte4(String b) {
String f = "\\]" ;
String temp = b.replaceAll(f," ");
return temp;
}
private static String delte5(String b) {
String f = "\\," ;
String temp = b.replaceAll(f," ");
return temp;
}
}
这是我改进的代码，这是根据测试点写的，但是分数还更少了。不如之前的代码。
课程成绩统计程序-2
这道题，我想道的还是用数组切割方法来实现。所以我在main函数写了许多切割方法，这是比较傻方法，我还采用了一个室友提供的方法。
这方法就不需要再写对应的传参方法了，很方便。我认为其实是很简单的，但是最难的是数据处理，特别是动态数据，我没啥处理方式，使用傻方法还是没有做出来。
这种方法我觉得是可行的，但是还是没写出来。
课程成绩统计程序-3
这道题我没仔细细看，那周的任务有点重。
jmu-Java-03面向对象基础-05-覆盖
这道题我用arraylist做过了一遍，我输出结果，发现没有问题啊，但是就是不让我过测试点，不清楚原因。
4.改进建议：
首先就是代码改进问题，我发现我写完后从来就没有想过改进的结果，我写题目集8时，必须要改进代码来缩短代码量。发现我没有尝试过这种情况。这不知道咋搞，后面我尝试题目集11的改进代码时，发现我用arraylist后，代码过不去，不如老代码。有点烦。
其次，没有系统处理问题能力，处理问题很死板，且没有了解过好方法，比较懒。这个还是要见的多了解多。写时，才能采用不同的方法。这里成绩系统2就可以体现。
5.总结：
首先就是pta出题时间的问题。最后一次pta我觉的出简单题就行，毕竟那时候会有许多考试与节课大作业。没有选择啊，况且那时候刚好英语4 6级考试，时间主要就安排不到pta上。
其次这几周我是把java这本书看了一遍，上面的例题我敲了一些，感觉比较简单，但其中一些方法真的值得推敲。
还学习了javafx的简单操作，这挺吃自学能力，当然乐趣也挺多的，这是第一次了解java魅力。
最后这几周，我是通过Java书与网上知识大致了解了一些解决问题的思路，我个人觉的很有用。
对于教学理念，我是挺赞成的。方法还是要练，但是思维脑筋是否转的过来，这主要看人。我猜很多人都是在第一次大题时就被Java给打败了，觉的Java太难了，失去学Java的兴趣。这时我建议前几周就强制让同学了解Java这本书，看看翻翻这本书，敲敲书上的代码，增强同学的兴趣与思考问题的勇气。
教学过程，pta一开始的迭代大题的难度可以降低些，且必须要学生对Java这本书首先要看过。我敢保证有些人是没有大致看过这本书的。且要对问题要多了解过，才能知道处理这种问题的代码套路。多了解一些标志问题有助于学生对迭代问题的方法实施。
例如这几次pta问题我主要是了解了字符串数组切割来处理数据，但如果换题了，可能还要去思考。这是一个可以尝试的方法，用小题来变化来培养学生处理数据的能力，可以帮助他们在些pta迭代大题有帮助。
教学方法，我建议是经常题目来包含以前的知识点，这样更容易让同学记住。
标签：总结性,return,第三次,int,blog,command,Integer,public,String From： https://www.cnblogs.com/fengyufeng/p/17500117.html