一、前言
这一阶段的题目集主要课程成绩设计的迭代，在这一题目里主要用到了正则表达式，准确来说正则表达式在这一题里占据十分重要的位置。这一阶段还考查到了数据结构的内容，像是栈和队列的使用。同时还涉及到了map和set数组的使用。在这一阶段我学到了许多新的知识，也对前面所学的内容进行了一个回顾和将其串联了起来。
二、设计与分析
第一道题是课程成绩设计的最初题目
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。
考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。
考察的总成绩直接等于期末成绩
必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。
1、输入：
包括课程、课程成绩两类信息。
课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。
课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式
课程性质输入项：必修、选修
考核方式输入选项：考试、考察
课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩
课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩
以上信息的相关约束：
1）平时成绩和期末成绩的权重默认为0.3、0.7
2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】
3）学号由8位数字组成
4）姓名不超过10个字符
5）课程名称不超过10个字符
6）不特别输入班级信息，班级号是学号的前6位。
2、输出：
输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。
为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。
1）学生课程总成绩平均分按学号由低到高排序输出
格式：学号+英文空格+姓名+英文空格+总成绩平均分
如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"
2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出
格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分
如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"
3）班级所有课程总成绩平均分按班级由低到高排序输出
格式：班级号+英文空格+总成绩平均分
如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"
异常情况：
1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"
2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"
以上两种情况如果同时出现，按第一种情况输出结果。
3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"
4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"
5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。
信息约束：
1）成绩平均分只取整数部分，小数部分丢弃
参考类图：
输入样例1:
仅有课程。例如：
java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end
输出样例1:
在这里给出相应的输出。例如：
java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet
输入样例2:
单门考试课程 单个学生。例如：
java 必修 考试
20201103 张三 java 20 40
end
输出样例2:
在这里给出相应的输出。例如：
20201103 张三 34
java 20 40 34
202011 34
输入样例3:
单门考察课程 单个学生。例如：
java 选修 考察
20201103 张三 java 40
end
输出样例3:
在这里给出相应的输出。例如：
20201103 张三 40
java 40 40
202011 40
输入样例4:
考试课程 单个学生 不匹配的考核方式。例如：
java 必修 考试
20201103 张三 java 20
end
输出样例4:
在这里给出相应的输出。例如：
20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例5:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
java 必修 考察
20201103 张三 java 40
end
输出样例5:
在这里给出相应的输出。例如：
java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet
输入样例6:
单门课程，多个学生。例如：
java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end
输出样例6:
在这里给出相应的输出。例如：
20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53
输入样例7:
单门课程，单个学生，课程类型与考核类型不匹配。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end
输出样例7:
在这里给出相应的输出。例如：
20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
输入样例8:
单门课程，单个学生，成绩越界。例如：
数据结构 选修 考察
20201103 李四 数据结构 101
end
输出样例8:
在这里给出相应的输出。例如：
wrong format
数据结构 has no grades yet
输入样例9:
多门课程，多个学生，多个成绩。例如：
形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end
输出样例9:
在这里给出相应的输出。例如：
20201102 王五 60 20201103 李四 87 20201205 李四 70 20201211 张三 75 java 60 60 数据结构 70 70 数据库 70 78 75 形式与政治 80 90 87 202011 73 202012 72
下面是我的代码
import java.util.*;
public class Main {
public static void main(String[] args) {
List<Curricula_Variable> xk = new ArrayList<>();
List<Course> courses = new ArrayList<>();
Course course = new Course();
List<Grade> classes = new ArrayList<>();
Grade cla = new Grade();
List<Student> students = new ArrayList<>();
Student student = new Student();
List<String> output = new ArrayList<>();//输出语句
List<String> id = new ArrayList<>();//学号姓名课程成绩
List<String> bj = new ArrayList<>();//班级号
Curricula_Variable cv = new Curricula_Variable();//null;
Test test = new Test();
Inspect inspect = new Inspect();
List<String> banjihaoma = new ArrayList<>();//班级号
List<String> coursename = new ArrayList<>();
int i = 0;
int flag5 = 0;//判断是否有学生信息
int poe = 0;//计算上某门课的学生人数
int e = 0;
//int poe = 0;//计算正确成绩数据
int t = 0;//计算总成绩
int q = 0,w = 0;
int f=0;
int d = 0;
Scanner put = new Scanner(System.in);
while(true) {
String input = put.nextLine();
if (input.equals("end")) {
break;
}
int k =0;
String[] temp = input.split(" ");
/*if(temp.length<=1){
output.add("wrong format");
continue;
}*/
if(temp.length==2&&temp[1].equals("必修")){
if(temp[0].length()>10){
output.add("wrong format");
continue;
}
else{
course = new Course(temp[0],temp[1],temp[2],0,0);
courses.add(course);
coursename.add(temp[0]);
}
}
if(temp.length==2&&!temp[1].equals("必修")){
output.add("wrong format");
continue;
}
if (temp.length == 3) {
if(temp[0].length()>10){
output.add("wrong format");
continue;
}
if(!temp[1].equals("必修")&&!temp[1].equals("选修")){
output.add("wrong format");
continue;
}
if(!temp[2].equals("考试")&&!temp[2].equals("考察")){
output.add("wrong format");
continue;
}
if(temp[1].equals("必修")){
if(/*!temp[2].equals("考试") && !temp[2].equals(" ")*/temp[2].equals("考察")){
output.add(temp[0]+" :"+" course type & access mode mismatch");
d=1;
continue;
}
}
if(courses.size()==0){
course = new Course(temp[0],temp[1],temp[2],0,0);
courses.add(course);
coursename.add(temp[0]);
}else{
for(i=0;i<courses.size();i++){
if(courses.get(i).getName().equals(temp[0])){
k=1;
}
}
if(k==0){
course = new Course(temp[0],temp[1],temp[2],0,0);
courses.add(course);
coursename.add(temp[0]);
}
}
}
if(temp.length==4||temp.length==5){
flag5++;//判断是否有学生信息
if(students.size()==0){
student = new Student(temp[0],temp[1],0,0,0);
students.add(student);
e=0;
}
else{
for(i=0;i<students.size();i++){
if(students.get(i).studentname.equals(temp[1])){
student=students.get(i);
e=1;
}}
if(e!=1){
student = new Student(temp[0],temp[1],0,0,0);
students.add(student);
e=0;
}
}
if(!temp[0].matches("^([0-9]{8})$")){//判断学号
output.add("wrong format");
continue;
}
if(temp[1].length()>10){//判断名字是否会超出限制
output.add("wrong format");
continue;
}
if(temp.length == 4){//判断分数
if(!temp[3].matches("^([1-9]?\\d|100)$")){
output.add("wrong format");
output.add(temp[2]+" "+"has no grades yet");
continue;
}
}
if(temp.length == 5){//判断分数
if(!temp[3].matches("^([1-9]?\\d|100)$") || !temp[4].matches("^([1-9]?\\d|100)$")){
output.add("wrong format");
output.add(temp[2]+" "+"has no grades yet");
continue;
}
}
for(i=0;i<courses.size();i++){
if(courses.get(i).getName().equals(temp[2])){//找到某门课
f++;
if(courses.get(i).getWay().equals("考察")&&temp.length==4){
banjihaoma.add(temp[0].substring(0, 6));
poe++;
inspect=new Inspect(Integer.parseInt(temp[3]));
student.addcha(inspect.score());
student.addorder(1);
//student = new Student(temp[0],temp[1],0,inspect.score(),0);
//id.add(temp[0]+" "+temp[1]+" "+inspect.score());//输出学生本门课程成绩
if(e==0){
id.add(temp[0]);
}
t = t + Integer.parseInt(temp[3]);//这门课的总成绩
courses.get(i).zong = t;
courses.get(i).people = courses.get(i).people+1;
}
if(courses.get(i).getWay().equals("考试")&&temp.length==5){
banjihaoma.add(temp[0].substring(0, 6));
poe++;
test=new Test(Integer.parseInt(temp[3]),Integer.parseInt(temp[4]));
//student = new Student(temp[0],temp[1],test.score(),0,0);//该学生该门课的成绩
//id.add(temp[0]+" "+temp[1]+" "+test.score());//输出学生本门课程成绩 该学生最终平均成绩
student.addtest(test.score());
student.addorder(1);
if(e==0){
id.add(temp[0]);
}
t = t + test.score();//这门课的总成绩
courses.get(i).pingshi=courses.get(i).pingshi+Integer.parseInt(temp[3]);
courses.get(i).kaoshi=courses.get(i).kaoshi+Integer.parseInt(temp[4]);
courses.get(i).zong = t;
courses.get(i).people = courses.get(i).people+1;
}
if(courses.get(i).getWay().equals("考察")&&temp.length==5){
output.add(temp[0] + " " + temp[1] + " " + ": access mode mismatch");
output.add(temp[0]+" "+temp[1]+" "+"did not take any exams");
output.add(courses.get(i).getName()+" has no grades yet");
output.add(temp[0].substring(0, 6)+" has no grades yet");
}
if(courses.get(i).getWay().equals("考试")&&temp.length==4){
output.add(temp[0] + " " + temp[1] + " " + ": access mode mismatch");
output.add(temp[0]+" "+temp[1]+" "+"did not take any exams");
output.add(courses.get(i).getName()+" has no grades yet");
output.add(temp[0].substring(0, 6)+" has no grades yet");
}
}
}
if (f == 0) {
output.add(temp[2] + " does not exist");//在课程列表中找不到课程}
output.add(temp[0]+" "+temp[1]+" "+"did not take any exams");
}
if(d==1){
output.add(temp[0].substring(0, 6)+" has no grades yet");
}
if (classes.size() == 0) {//如果没有班级信息
cla.number = temp[0].substring(0, 6);
cla.students.clear();
cla.addstudent(student);
classes.add(cla);
} else {
int m = 0;
for (i = 0; i < classes.size(); i++) {//将学生信息添加到对应班级
if (classes.get(i).getNumber().equals(temp[0].substring(0, 6))) {
classes.get(i).addstudent(student);
m=1;
break;
}}
if(m!=1){
cla.number = temp[0].substring(0, 6);//有班级信息但没有当前班级的信息
cla.students.clear();
cla.addstudent(student);
classes.add(cla);
}
}
}
}//while ()
for( i = 0;i < coursename.size();i++){
if(xk.size() == 0&&flag5==0){
output.add(coursename.get(i) +" has no grades yet");
}
}
Collections.sort(id);
Collections.sort(coursename);
//System.out.println(coursename.get(0));
//System.out.println(courses.get(0).xingzhi);
for(i=0;i<id.size();i++){//输出学生总成绩平均分
//id.forEach(System.out::println);
for(int j=0;j<students.size();j++){
//id.forEach(System.out::println);
if(students.get(j).id.equals(id.get(i))){
output.add(students.get(j).id+" "+students.get(j).studentname+" "+/*students.get(j).cha*/students.get(j).staver());
}
}
}
if(poe!=0){
for(i=0;i<coursename.size();i++){//输出课程平均分
for(int j = 0;j<courses.size();j++){
if(coursename.get(i).equals(courses.get(j).getName())){//找到课程
if(courses.get(j).getWay().equals("考察")){
output.add(courses.get(j).getName()+" "+courses.get(j).average()+" "+courses.get(j).average());
}
if(courses.get(j).getWay().equals("考试")){
output.add(courses.get(j).getName()+" "+courses.get(j).pingsaverage()+" "+courses.get(j).kaosaverage()+" "+courses.get(j).average());
}}
}
}}
Collection<String> list2 = new HashSet<>();
list2.addAll(banjihaoma);
Object[] object = list2.toArray();
//list2.forEach(System.out::println);
for(i=0;i<list2.size();i++){//输出班级平均分
for(int j =0;j<classes.size();j++){
if(classes.get(j).number.equals(object[i])){
if(classes.get(j).banjijunfen()<0||classes.get(j).banjijunfen()>100){
output.add(classes.get(j).number+" "+"has no grades yet");
}
else{
output.add(classes.get(j).number+" "+classes.get(j).banjijunfen());
}
}
}
}
/*if(poe!=0){
String r = cla.getNumber() +" "+t/poe;//班级
String c ="";
if(kaoshifangshi.equals("考试")){
c = course.getName() +" "+course.pingsaverage()+" "+course.kaosaverage()+" "+course.average();
}
else{
c = course.getName() +" "+t/poe+" "+t/poe;
}
output.add(c);
output.add(r);
}
/*if(poe==0){
for(i=0;i<courses.size();i++){
output.add(courses.get(i).getName()+" has no grades yet");
}
}*/
/*if(d !=0){
xk.
output.add(id.get(0).)
}*/
/*for(i=0;i<xk.size();i++){
if()
}*/
for (String s : output) {
System.out.printf(s+"\n");
}
}//方法
}//类
class Curricula_Variable{
private Course course = new Course();
private Student student = new Student();
public Curricula_Variable() {
}
public Curricula_Variable(Course course, Student student) {
this.course = course;
this.student = student;
}
public Course getCourse() {
return course;
}
public Student getStudent() {
return student;
}
}
class Course{
private String name;
String xingzhi;
private String way;
int pingshi = 0;
int kaoshi = 0;
int zong=0;
int people = 0;
public Course() {
}
public Course(String name, String xingzhi, String way, int pingshi, int kaoshi) {
this.name = name;
this.xingzhi = xingzhi;
this.way = way;
this.pingshi = pingshi;
this.kaoshi = kaoshi;
}
public int average(){
double average = this.zong/this.people;
return (int)average;
}
public int pingsaverage(){
double pingshiaverage = this.pingshi/this.people;
return (int) pingshiaverage;
}
public int kaosaverage(){
double pingshiaverage = this.kaoshi/this.people;
return (int) pingshiaverage;
}
public String getName() {
return name;
}
public String getWay() {
return way;
}
}
class Student{
String id;
String studentname;
int shi = 0;
int cha = 0;
int order = 0;//参与的考试数量
public Student() {
}
public Student(String id, String studentname, int shi, int cha, int order) {
this.id = id;
this.studentname = studentname;
this.shi = shi;
this.cha = cha;
this.order = order;
}
public void addtest(int t){//考试的最终成绩
this.shi=shi+t;
}
public void addcha(int t){//考察的最终成绩
this.cha=cha+t;
}
public void addorder(int t){
this.order=order+t;
}
public int staver(){//学生总成绩平均分
int a = (this.cha+this.shi)/order;
return a;
}
public int getShi() {
return shi;
}
public int getCha() {
return cha;
}
public int getOrder() {
return order;
}
}
abstract class Score{
private int usual;//平时成绩
public Score() {
}
public Score(int usual) {
this.usual = usual;
}
public int getUsual() {
return usual;
}
public abstract int score();
}
class Test extends Score{
private int ks;//考试成绩
public Test() {
}
public Test(int usual, int ks) {
super(usual);
this.ks = ks;
}
public int getKs() {
return ks;
}
@Override
public int score() {
double sum = 0.3 * getUsual() + 0.7 * ks;
return (int)sum;
}
}
class Inspect extends Score{
public Inspect() {
}
public Inspect(int usual) {
super(usual);
}
@Override
public int score() {
return getUsual();
}
}
class Grade {
String number;
List<Student> students = new ArrayList<>();
int i =0;
public Grade() {
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public void addstudent(Student student){
students.add(student);
}
public int banjijunfen(){
int a = 0;
for(int i=0;i<this.students.size();i++){
a = a+ this.students.get(i).staver();
}
a = a/this.students.size();
return a;
}
}
这道题真的是写了好久，想起来都是泪，连着熬了两天到凌晨三点的大夜。其实我感觉这个题的设计思想和之前写的菜单题的思想是差不多的。都是对输入的内容进行逐一的运行，通过输入的字符长度进行不同的操作。在这里也也是对于菜单题的一个总结，也是因为菜单题这题做起来有些思路，这道题里我规范了我的Javabeng代码对每一个类都有gettet和setter以及构造方法。而且这道题还限制了代码长度，一开始五百行代码是无法提交的，后来更改了设计的思想，代码改到四百多行才能提交。在主函数里对输入的内容进行分析判断，来将错误的输入进行对应的输出，这里将输出语句都加进了一个字符串数组里，这个数组是用array来进行定义的，最后在主类里一起输出。这道题我一共建了九个类，grade类来储存班级信息，这个类包含了学生的信息以及班级学生的人数，学生信息也是用array建了一个数组来储存的，我发现这个array是真好用啊，比数组好用多了，首先它不用送一数组长度，添加书序元素的时候直接add不用整个for循环才能进行赋值。回到正题，grade类里添加了学生信息主要是想对这个班级的班级平均分进行判断，如果平均分不符合规则就是错的，再进行对应的输出。然后将考试和考查两种考试方式分别创建了一个类，并且两个类都继承自分数类。类之间的关系完全是按照题给类图来的。这道题里用了许多数组来分门别类的储存各种信息。
2、菜单五
本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。
注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-3的两个不同迭代分支。
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 三个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 口味度 份额 份数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号\\
Dish d;//菜品\\
int portion;//份额（1/2/3代表小/中/大份）\\
int getPrice()//计价，计算本条记录的价格\\
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
### 输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+”:”
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
以上为菜单计价系列-3的题目要求，加粗的部分是有调整的内容。本次课题相比菜单计价系列-3新增要求如下：
1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"
例如：麻婆豆腐 川菜 9 T
菜价的计算方法：
周一至周五 7折， 周末全价。
特色菜的口味类型：川菜、晋菜、浙菜
川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；
晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；
浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；
例如：麻婆豆腐 川菜 9 T
输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数
例如：1 麻婆豆腐 4 1 9
单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：
acidity num out of range : 5
输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。
一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。
如果整桌菜没有特色菜，则只输出table的基本信息，格式如下，注意最后加一个英文空格：
table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格
例如：table 1: 60 36 川菜 2 爆辣 浙菜 1 微甜
计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。
注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。
2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：
格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
例如：table 1 : tom 13670008181 2023/5/1 21/30/00
约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。
输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有table金额都要累加。
输出用户支付金额格式：
用户姓名+英文空格+手机号+英文空格+支付金额
注意：不同的四舍五入顺序可能会造成误差，请按以下步骤累计一桌菜的菜价：
计算每条记录的菜价：将每份菜的单价按份额进行四舍五入运算后，乘以份数计算多份的价格，然后乘以折扣，再进行四舍五入，得到本条记录的最终支付价格。
将所有记录的菜价累加得到整桌菜的价格。
输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+口味类型+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+辣/酸/甜度值+英文空格+份额+英文空格+份数 注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。辣/酸/甜度取值范围见题目中说明。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称**+英文空格+辣/酸/甜度值+**英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+“:”+英文空格
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
之后按输入顺序一次输出每一桌所有菜品的价格（整数数值），
格式：table+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格
最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式： 用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。
输入样例1:
桌号时间超出营业范围。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 21/30/00
1 麻婆豆腐 3 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end
输出样例1:
在这里给出相应的输出。例如：
table 1 out of opening hours
输入样例2:
一种口味的菜品。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 20/30/00
1 麻婆豆腐 2 1 2
2 油淋生菜 2 1
3 麻婆豆腐 2 3 2
end
输出样例2:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 24
2 油淋生菜 14
3 麻婆豆腐 48
table 1: 86 62 川菜 4 稍辣
tom 13605054400 62
输入样例3:
辣度值超出范围。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 6 1 2
2 油淋生菜 1 1
3 麻婆豆腐 5 3 2
end
输出样例3:
在这里给出相应的输出。例如：
table 1:
spicy num out of range :6
2 油淋生菜 9
3 麻婆豆腐 48
table 1: 57 41 川菜 2 爆辣
tom 13605054400 41
输入样例4:
同一用户对应多桌菜。例如：
麻婆豆腐 川菜 12 T
油淋生菜 9
麻辣鸡丝 10
table 1 : tom 13605054400 2023/5/1 18/30/00
1 麻婆豆腐 1 1 2
2 油淋生菜 1 1
3 麻婆豆腐 2 2 2
table 2 : tom 13605054400 2023/5/6 18/30/00
1 麻婆豆腐 2 1 2
2 麻辣鸡丝 2 2
3 麻婆豆腐 2 1 1
end
输出样例4:
在这里给出相应的输出。例如：
table 1:
1 麻婆豆腐 24
2 油淋生菜 9
3 麻婆豆腐 36
table 2:
1 麻婆豆腐 24
2 麻辣鸡丝 30
3 麻婆豆腐 12
table 1: 69 49 川菜 4 稍辣
table 2: 66 66 川菜 3 稍辣
tom 13605054400 115
输入样例5:
多用户多桌菜。例如：
东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 1 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : jerry 18100334566 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end
输出样例5:
在这里给出相应的输出。例如：
table 1:
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2:
1 醋浇羊肉 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3:
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 4 稍酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣 晋菜 2 微酸
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 191
tom 13605054400 113
输入样例6:
多用户多桌菜含代点菜。例如：
东坡肉 浙菜 25 T
油淋生菜 9
蜜汁灌藕 浙菜 10 T
刀削面 晋菜 10 T
醋浇羊肉 晋菜 30 T
麻婆豆腐 川菜 12 T
麻辣鸡丝 川菜 15 T
table 1 : tom 13605054400 2023/5/6 12/30/00
1 醋浇羊肉 4 1 1
3 刀削面 1 1 3
2 东坡肉 3 2 1
4 麻辣鸡丝 2 1 1
table 2 : jerry 18100334566 2023/5/1 12/30/00
1 1 醋浇羊肉 0 1 2
3 麻婆豆腐 2 2 1
4 麻辣鸡丝 2 3 3
table 3 : lucy 18957348763 2023/5/1 12/30/00
1 醋浇羊肉 2 1 1
3 蜜汁灌藕 1 1 2
2 东坡肉 2 2 1
4 麻辣鸡丝 5 1 1
end
输出样例6:
在这里给出相应的输出。例如：
table 1:
1 醋浇羊肉 30
3 刀削面 30
2 东坡肉 38
4 麻辣鸡丝 15
table 2:
1 table 2 pay for table 1 60
3 麻婆豆腐 18
4 麻辣鸡丝 90
table 3:
1 醋浇羊肉 30
3 蜜汁灌藕 20
2 东坡肉 38
4 麻辣鸡丝 15
table 1: 113 113 川菜 1 稍辣 晋菜 6 微酸 浙菜 1 甜
table 2: 168 118 川菜 4 稍辣
table 3: 103 73 川菜 1 爆辣 晋菜 1 稍酸 浙菜 3 微甜
jerry 18100334566 118
lucy 18957348763 73
tom 13605054400 113
输入样例7:
错误的菜品记录和桌号记录，用户丢弃。例如：
东坡肉 25 T
油淋生菜 9
table 1 : tom 136050540 2023/5/1 12/30/00
2 东坡肉 3 2 1
end
输出样例7:
在这里给出相应的输出。例如：
wrong format wrong format
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Calendar;
public class Main {
public static Menu menu = new Menu();
public static void main(String[] args) {
Scanner p = new Scanner(System.in);
//Order order = new Order();
int x = 0;
Table h = new Table();
String cuisine = null;
//String []dishname = new String[100];
int dishnum = 0;
int d = 0;
int i = 0;
int b = 0;//判断桌号输出次数
int c = 1;//判断订单序号是否正确
boolean k = true;
while(true) {
String start = p.nextLine();
if(start.equals("end")) {
break;
}
String t[] = start.split(" ");
int w = t.length;
//菜单
if(w == 3) {
System.out.println("wrong format");
}
if(w == 4 && t[0].length()!=1) {//输入特色菜
if(!t[3].equals("T")) {
System.out.println("wrong format");
}
if(t[1].equals("川菜")) {
cuisine = "川菜";
}
if(t[1].equals("浙菜")) {
cuisine = "浙菜";
}
if(t[1].equals("晋菜")) {
cuisine = "晋菜";
}
menu.addDish(t[0],Integer.parseInt(t[2]));
d++;
}
if(w == 2 && t[0].length()!=1) {//输入非特色菜
menu.addDish(t[0],Integer.parseInt(t[1]));
d++;
}
//订单
if(t[0].equals("table") && w ==7) {//没有判断table输入错误的情况
//还没有判断日期时间的输入格式，用正则判断
if (Integer.parseInt(t[1]) > 55 || Integer.parseInt(t[1]) < 1) {
System.out.println(" table num out of range"+t[1]);
continue;
}
if(t[3].length() > 10) {
System.out.println("wrong format");
continue;
}
if(!t[4].matches("^180|181|189|133|135|136([0-9]{8})$")) {
System.out.println("wrong format");
continue;
}
h.setName(t[3],t[4],Integer.parseInt(t[1]));//存入名字电话号和桌号信息
k = h.processTime(t[5], t[6]);//判断时间
continue;
}
if(w == 5 && t[0].length() == 1) {//特色菜订单
if(!isInteger(t[0]) ) {
System.out.println("wrong format");
}
if(k==false) {
System.out.println("table "+h.getNum()+" out of opening hours");
return;
}
int a = 0;
if(b == 0 && k == true) {
System.out.println("table "+h.num+": ");
b++;
}
if(cuisine.equals("川菜")) {
if(Integer.parseInt(t[2]) > 5 || Integer.parseInt(t[2]) < 0) {//口味不对
System.out.println("spicy num out of range :"+Integer.parseInt(t[2]));
a = 1;
c++;
/*return*/continue;
}
}
if(cuisine.equals("浙菜")) {
if(Integer.parseInt(t[2]) > 3 || Integer.parseInt(t[2]) < 0) {//口味不对
System.out.println("sweetness num out of range :"+Integer.parseInt(t[2]));
a = 1;
c++;
//return/*continue*/;
/*return*/continue;
}
}
if(cuisine.equals("晋菜")) {
if(Integer.parseInt(t[2]) > 4 || Integer.parseInt(t[2]) < 0) {//口味不对
System.out.println("acidity num out of range :"+Integer.parseInt(t[2]));
a = 1;
c++;
/*return*/continue;
}
}
if(Integer.parseInt(t[3]) != 1 && Integer.parseInt(t[3]) != 2 && Integer.parseInt(t[3]) != 3) {//份额不对
System.out.println("portion out of range "+Integer.parseInt(t[3]));
a = 1;
c++;
/*return*/continue;
}
if(Integer.parseInt(t[0]) != c) {
System.out.println("wrong format");
return/*continue*/;
}
if(a == 0 ) {
h.order.records[i] = new Record();
h.order.addARecord(t[1],Integer.parseInt(t[3]),Integer.parseInt(t[4]),Integer.parseInt(t[0])/*菜的序号*/);
dishnum++;
System.out.println(Integer.parseInt(t[0])+" "+t[1]+" "+h.order.records[dishnum-1].getPrice());
x = x + h.order.records[dishnum-1].getPrice();
i++;
c++;
//return/*continue*/;
}
}
if(w == 4 && t[0].length() == 1) {//非特色菜订单
if(!isInteger(t[0])) {
System.out.println("wrong format");
}
if(k == false) {
return;
}
int a = 0;
if(b == 0 && k == true) {
System.out.println("table "+h.num+": ");
b++;
a = 1;
}
if(Integer.parseInt(t[2]) != 1 && Integer.parseInt(t[2]) != 2 && Integer.parseInt(t[2]) != 3) {//判断份额
System.out.println("portion out of range "+Integer.parseInt(t[2]));
a = 1;
c++;
/*return*/continue;
}
if(Integer.parseInt(t[0]) != c) {
System.out.println("wrong format");
/*return*/continue;
}
if(a == 0) {
h.order.records[dishnum] = new Record();
h.order.addARecord(t[1],Integer.parseInt(t[2]),Integer.parseInt(t[3]),Integer.parseInt(t[0])/*菜的序号*/);
dishnum++;
System.out.println(Integer.parseInt(t[0])+" "+t[1]+" "+h.order.records[dishnum-1].getPrice());
//return/*continue*/;
x = x + h.order.records[dishnum-1].getPrice();
c++;
}
}
}//while括号
System.out.println("hh");
}
private static boolean isInteger(String t) {
Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
return pattern.matcher(t).matches();
}}
class Dish {
String name;//菜品名称
int unit_price; //单价
public Dish() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getUnit_price() {
return unit_price;
}
public void setUnit_price(int unit_price) {
this.unit_price = unit_price;
}
public int getPrice(int portion){ //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
double a = 1;
switch(portion) {
case 1:a = unit_price;break;
case 2:a = unit_price * 1.5;break;
case 3:a = unit_price *2.0;break;
}
a = a +0.5;//四舍五入
int b = (int)a;
return b;
}
}
class Menu {
Dish[] dishes = new Dish[55];
int i = 0;
public Menu() {
}
public Dish addDish(String dishName,int unit_price/*,int orderNum*/){//添加一道菜品信息
dishes[i] = new Dish();
this.dishes[i].name = dishName;
this.dishes[i].unit_price = unit_price;
i++;
return this.dishes[i-1];
}
public Dish searthDish(String dishName){//根据菜名在菜谱中查找菜品信息，返回Dish对象。
int j = 0;
int a = 0,b = 0;
for(j=0;j<8;j++) {
if(dishes[j].name.equals(dishName)) {
a = 1;
b = j;
break;
}}
if(a == 0) {
System.out.println(dishName+" does not exist");//存不进菜品
return null;
}
else return dishes[b];
}
}
class Order {//保存订单上每一道的记录
Record[] records=new Record[55];//保存订单上每一道的记录
int i = 0;
public Record addARecord(String dishName,int portion,int copies,int ordernum){//添加一条菜品信息到订单中。num是第几次订单
records[i] = new Record();
records[i].d.name = dishName;//d内菜品价格还不知道需要查找菜品然后再知道其价格
records[i].portion = portion;
records[i].copies = copies;
records[i].orderNum = ordernum;
i++;
return records[i-1];
}//添加一条菜品信息到订单中。*/
public int delARecordByOrderNum(int orderNum){//根据序号删除一条记录
if(orderNum>i||orderNum<=0){
System.out.println("delete error;");
return 0;
}else {
return records[orderNum - 1].getPrice();
}
}//根据序号删除一条记录
public int getTotalPrice(){//计算订单的总价
records[i] = new Record();
int j = 0;
for(int m = 0;m < i;m++) {
j = j + records[m].getPrice();
}
return j;
}
/*public findRecordByNum(int orderNum){//根据序号查找一条记录
}*/
}
class Record {
//Menu menu = new Menu();
int orderNum; //序号桌号
Dish d = new Dish();
String f = d.name;
int portion; //份额（1/2/3代表小/中/大份）
int copies;//点菜份数
public Record() {
}
public int getPrice(){//计价，计算本条记录的价格
if(Main.menu.searthDish(d.name)!=null){
int g = (Main.menu.searthDish(d.name).getPrice(portion)) * copies;
return g;}
else
return 0;
}
}
class Table {
String name;
String cell;
int num = 100/*桌号吧*/,week = 0,i = 0;
/*String nyr/*,sfm;
String sfm = null;*/
double discnt = 0;
int flag = 0;
Order order = new Order();
//Order[] order = new Order[77];
//Table table = new Table();
public Table() {
}
/*public Table add(String name,String cell,int num) {
table.cell = cell;
table.name = name;
table.num = num;
return table;
}*/
public boolean processTime(String nyr,String sfm){//处理时间
String[] q = nyr.split("/");//年月日
int year = Integer.parseInt(q[0]);
int month = Integer.parseInt(q[1]);
int day = Integer.parseInt(q[2]);
Calendar c = Calendar.getInstance();
c.set(year, (month), day);
week = c.get(Calendar.DAY_OF_WEEK);
if(week==1)
week = 7;
else
week--;
String[] r = sfm.split("/");//时分秒
int hous = Integer.parseInt(r[0]);
int m = Integer.parseInt(r[1]);
int s = Integer.parseInt(r[2]);
//public float getprice() {
order = new Order();
float pc = order.getTotalPrice();
if(week>=1&&week<=5)
{
if(hous>=17&&hous<20)
discnt=0.8*pc;
else if(hous==20&&m<30)
discnt=0.8*pc;
else if(hous==20&&m==30&&s == 0)
discnt=0.8*pc;
else if(hous>=11&&hous<=13||hous==10&&m>=30)
discnt=0.6*pc;
else if(hous==14&&m<30)
discnt=0.6*pc;
else if(hous==14&&m==30&&s==0)
discnt=0.6*pc;
}
else
{
if(hous>=10&&hous<=20)//周末
discnt= 1.0*pc;
else if(hous==9&&m>=30)
discnt= 1.0*pc;
else if(hous==21&&m<30||hous==21&&m==30&&s==0)
discnt= 1.0*pc;
}
if(hous <= 9 || hous >= 21 || hous == 9 && m < 30 || hous == 21 && m >= 30) //时间越界
//System.out.println("table "+num+" out of opening hours");
//this.flag = 1;
return false;
return true;
// else System.out.println("table "+num+":"+" ");
}
public double getprice() {
return discnt;
}
public void show() {
System.out.println(order.getTotalPrice());
System.out.println(name);
System.out.println(cell);
}
public String getName() {
return name;
}
public void setName(String name,String cell,int num) {
this.name = name;
this.cell = cell;
this.num = num;
}
public String getCell() {
return cell;
}
public void setCell(String cell) {
this.cell = cell;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public double getDiscnt() {
return discnt;
}
public void setDiscnt(double discnt) {
this.discnt = discnt;
}
public int getFlag() {
return flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
public Order getOrder() {
return order;
}
public void setOrder(Order order) {
this.order = order;
}
}
3、
编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：
- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法
输入格式:
输入Java源码字符串，可以一行或多行，以exit行作为结束标志
输出格式:
- 当未输入源码时，程序输出
Wrong Format - 当没有统计数据时，输出为空
- 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为
数量\t关键字
输入样例:
在这里给出一组输入。例如：
//Test public method
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
exit
输出样例:
在这里给出相应的输出。例如：
1 float 3 if 2 int 2 new 2 public 3 this 2 throw
import java.util.*;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String p;
StringBuilder sb=new StringBuilder();
HashSet hs = new HashSet<>();
Map<String, Integer> tm=new TreeMap<String, Integer>();
String []key= { "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;
while(true){
p=input.nextLine();
if(p.equals("exit"))
break;
if(p.matches("(.*)//(.*)")){
String b[]=p.split("//");//删去"//"单行注释
sb.append(b[0]+" ");
}
else
{sb.append(p+" ");
}
}
String s=sb.toString();
Pattern q=Pattern.compile("\"(.*?)\"");
Matcher m=q.matcher(s);
while(m.find()){
s=s.replace(m.group()," ");
q=Pattern.compile("\"(.*?)\"");
m=q.matcher(s);
}
q=Pattern.compile("/\\**(.*?)/");
m=q.matcher(s);
while(m.find()){
s=s.replace(m.group()," ");
m=q.matcher(s);
}
if(s.isEmpty()){
System.out.println("Wrong Format");
System.exit(0);
}
s=s.replace("["," ");//用空格替换符号
s=s.replace("]"," ");
s=s.replace("-"," ");
s=s.replace(","," ");
s= s.replaceAll("[^a-zA-Z]", " ");//删掉字符串
String[] s1=s.split("[ ' ']");
for(int i=0;i<s1.length;i++){//先输入关键字
//System.out.println(s1[i]);
for(int j=0;j<key.length;j++)
if(s1[i].equals(key[j]))
{
tm.put(key[j], 0);
}
}
for( int i = 0;i<s1.length;i++){//计算关键字个数
for(int j=0;j<key.length;j++)
if(s1[i].equals(key[j]))
{ count=tm.get(key[j]);
tm.put(key[j], count+1);
}
}
Set<Map.Entry<String,Integer>> sets=tm.entrySet();//输出用set
for(Map.Entry<String,Integer> entry:sets){
System.out.println(entry.getValue()+"\t"+entry.getKey());
}
}
}
这道题用到了map和set，map和set数组都是不能储存重复的元素，其中map有key和value两个元素，key不可以相同但是value可以相同，如果输入相同的key那么后输入的那个会把前面的key进行覆盖，这道题先用正则表达式对输入的字符串进行整理，把空格之类的字符和字符串里的语句删除掉会用的正则表达式的replace方法，然后再将这些整理好的字符串与关键字所在数组进行匹配如果匹配上了那么map的value就加一最后再进行输出。
4、
题目描述
编辑
输入多个学生的成绩信息，包括：学号、姓名、数学成绩、物理成绩。
学号是每个学生的唯一识别号，互不相同。
姓名可能会存在重复。
要求：使用ArrayList存储学生信息。
输入格式:
输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+数学成绩+英文空格+物理成绩
以“end”为输入结束标志
输出格式:
按数学/物理成绩之和从高到低的顺序输出所有学生信息，每个学生信息的输出格式：学号+英文空格+姓名+英文空格+数学/物理成绩之和
成绩相同的情况，按输入的先后顺序输出。
输入样例:
在这里给出一组输入。例如：
20201124 张少军 83 75
20201136 李四 78 86
20201118 郑觉先 80 62
end
输出样例:
在这里给出相应的输出。例如：
20201136 李四 164
20201124 张少军 158
20201118 郑觉先 142