Java博客作业（三）

一、前言

题目集七

知识点：菜单计价系统

题量：少

难度：较难

题目集八

知识点：课程成绩统计、使用comparable接口处理信息排序、ArrayList的使用、正则表达式

题量：中等

难度：较难

题目集九

知识点：统计Java程序中关键词出现次数、HashMap、HashSet、Matcher、Pattern、treeMap。

题量：少

难度：较难

题目集十

知识点：HashMap-检索、HashMap-排序、多态、课程成绩统计系统

题量：一般

难度：较难

题目集十一

知识点：ArrayList-排序、Comparable接口、Stack、面向对象基础-覆盖

题量：一般

难度：较难

 

二、设计与分析 与 踩坑心得

题目集七

菜单计价程序-5

       又是菜单计价程序题的迭代，不过此次题目并非是菜单-4的迭代，而是菜单-3的另一个迭代分支，这也意味着此次难度并不会比上次大。此次题目主要对特色菜进行了川菜、晋菜、浙菜的区分，并且增加了口味度。在输入信息方面，除添加的口味度信息外，为了考虑客户订多桌菜的情况，输入桌号时，还将增加用户的信息，如用户姓名、电话号码。在输出方面，要求先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。

我新建了Costomr类，里面主要有三个参数：name用户姓名、telnum用户电话号码、sumprice用户订单总价.

以及两个方法：Setcustomer(String name, String telnum,int sumprice)用来添加用户信息、paixu()对用户信息进行排序（按用户名字字母顺序）。相应代码如下：

public void Setcustomer(String name, String telnum,int sumprice) {
        if(i==0) {//保存第一位用户
            this.name[i] = name;
            this.telnum[i] = telnum;
            this.sumprice[i] = sumprice;
            i++;
        }
        else {//
            for(j=0; j<i ;j++) {
                if(this.name[j].equals(name)) {//同一个用户
                    this.sumprice[j] += sumprice;//更改用户支付总价
                    k = 0;
                }
            }
            if(k == 1){//新用户
                this.name[i] = name;
                this.telnum[i] = telnum;
                this.sumprice[i] = sumprice;
                i++;
            }
        }
    }

public void paixu() {
        int n = 0;
        int m = 0;
        String temp = "";
        int t = 0;
        for(n=0;n<i-1;n++) {
            for(m=n;m<i-1;m++) {
                if(this.name[m].charAt(0)>this.name[m+1].charAt(0)) {
                    temp=name[m];
                    name[m]=name[m+1];
                    name[m+1]=temp;
                    temp=telnum[m];
                    telnum[m]=telnum[m+1];
                    telnum[m+1]=temp;
                    t=sumprice[m];
                    sumprice[m]=sumprice[m+1];
                    sumprice[m+1]=t;
                }
            }
        }
    }

Dish类中新增了type属性，用来区分菜品是否是特色菜以及特色菜类型（普通菜为“普通”，特色菜为“川菜”、“晋菜”、“浙菜”）。

Order类中新增avspicy、avsour、avsweet等属性用来表示订单平均口味度值。word(String type)方法用于判定口味度值对应的口味度。相应代码如下：

public String word(String type) {
        if(type.equals("川菜")) {
            int n = (int)Math.round(avspicy);
            switch(n) {
                case 0: return "不辣";
                case 1: return "微辣";
                case 2: return "稍辣";
                case 3: return "辣";
                case 4: return "很辣";
                case 5: return "爆辣";
            }
        }
        else if(type.equals("晋菜")) {
            int n = (int)Math.round(avsour);
            switch(n) {
                case 0: return "不酸";
                case 1: return "微酸";
                case 2: return "稍酸";
                case 3: return "酸";
                case 4: return "很酸";
            }
        }
        else if(type.equals("浙菜")) {
            int n = (int)Math.round(avsweet);
            switch(n) {
                case 0: return "不甜";
                case 1: return "微甜";
                case 2: return "稍甜";
                case 3: return "甜";
            }
        }
        return null;
    }

至于代码主体部分，依旧是沿用之前的方法，使用while（）循环处理每一行数据，对每行字符串个数count进行 if 判定，如count==4时，为向菜单中添加特色菜品信息或点单且菜品为普通菜，之后再在内部不断细化。

本次题目整体难度其实并不高，相比菜单4其实更好拿分，并且有了前几次的经验，理解题意并付诸实践会更加容易，稍微令人头痛的不是基本的逻辑关系了，更多的是规定的输出形式，如对空格以及特定地区换行和wrong format等异常情况的处理。

本题完整代码如下：

import java.util.Scanner;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
         Scanner sc = new Scanner(System.in);
         Menu menu = new Menu();
         Table[] tablemes = new Table[10];
         String  dishName; //dishName为用户输入的菜名
         String[] temp;
         int orderNum=0, delete_Num, portion, amount, delete_Price = 0;
         int i=0,j=0;
         int tablenum=0;
         int onum = 0;
         int dengji = 0;
         String type = "普通";
         Dish dish;
         while (true) {
                String st = sc.nextLine();
                temp = st.split(" ");
                if(st.equals("end"))
                    break;
                int count = temp.length;
                if (count == 2) {
                    if (temp[1].equals("delete")) {//第二个为delete
                        onum = Integer.parseInt(temp[0]);
                        int c = tablemes[tablenum].torder.delARecordByOrderNum(onum);
                        //有删除菜品记录，则将此记录菜品价格赋给c，没有则输出"delete error;"
                        if(tablemes[tablenum].torder.findRecordByNum(onum)!=null) {//删除的菜品记录存在
                            if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("普通")) {//删除菜品为普通菜
                                tablemes[tablenum].sumprice -= c;
                                tablemes[tablenum].disprice -= Math.round( c*tablemes[tablenum].discount);
                            }
                            else {//删除菜品为特色菜
                                tablemes[tablenum].sumTprice -= c;
                                tablemes[tablenum].disprice -= Math.round( c*tablemes[tablenum].Tdiscount);
                                if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("川菜")) {
                                    tablemes[tablenum].torder.avspicy = 
                                            (tablemes[tablenum].torder.avspicy * tablemes[tablenum].torder.chuancai -
                                            tablemes[tablenum].torder.findRecordByNum(onum).dengji * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
                                            (tablemes[tablenum].torder.chuancai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
                                    tablemes[tablenum].torder.chuancai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
                                }
                                else if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("晋菜")) {
                                    tablemes[tablenum].torder.avsour = 
                                            (tablemes[tablenum].torder.avsour * tablemes[tablenum].torder.jincai -
                                            tablemes[tablenum].torder.findRecordByNum(onum).dengji * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
                                            (tablemes[tablenum].torder.jincai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
                                    tablemes[tablenum].torder.jincai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
                                }
                                else if(tablemes[tablenum].torder.findRecordByNum(onum).d.type.equals("浙菜")) {
                                    tablemes[tablenum].torder.avsweet = 
                                            (tablemes[tablenum].torder.avsweet * tablemes[tablenum].torder.zhecai -
                                            tablemes[tablenum].torder.findRecordByNum(onum).dengji * tablemes[tablenum].torder.findRecordByNum(onum).amount) /
                                            (tablemes[tablenum].torder.zhecai - tablemes[tablenum].torder.findRecordByNum(onum).amount);
                                    tablemes[tablenum].torder.zhecai -= tablemes[tablenum].torder.findRecordByNum(onum).amount;
                                }
                            }
                        }
                        
                    }
                    else {//普通菜增加
                        menu.addDish(temp[0], Integer.parseInt(temp[1]),"普通");
                    }
                }
                
                else if (count == 4) {
                    if(temp[3].equals("T")) {//特色菜增加
                        menu.addDish(temp[0], Integer.parseInt(temp[2]), temp[1]);
                    }
                    else {
                        //普通菜点单//增加订单的情况；
                        onum =Integer.parseInt(temp[0]);
                        dishName =temp[1];
                        portion = Integer.parseInt(temp[2]);
                        amount = Integer.parseInt(temp[3]);
                        tablemes[tablenum].torder.addARecord(onum,dishName,-1,portion,amount,"普通");
                        dish = menu.searchDish(dishName);
                        if (dish != null) {
                            tablemes[tablenum].torder.records[orderNum].d = dish;
                            int a = tablemes[tablenum].torder.records[orderNum].getPrice();
                            if(tablemes[tablenum].discount>0)
                                System.out.println(tablemes[tablenum].torder.records[orderNum].orderNum + " " + dish.name + " " +a );
                            tablemes[tablenum].sumprice +=a;
                            tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].discount);
                        }
                        orderNum++;
                    }
                }
                
                else if(count == 5){//特色菜点单//增加订单
                    onum =Integer.parseInt(temp[0]);
                    dishName =temp[1];
                    dengji = Integer.parseInt(temp[2]);
                    portion = Integer.parseInt(temp[3]);
                    amount = Integer.parseInt(temp[4]);
                    dish = menu.searchDish(dishName);
                    type = dish.type;
                    if(!dish.validengji(type, dengji)) {  // type的辣度等级不合法
                        if(type.equals("川菜")) {
                            System.out.println("spicy num out of range :"+dengji);
                        }
                        else if(type.equals("晋菜")) {
                            System.out.println("acidity num out of range :"+dengji);
                        }
                        else if(type.equals("浙菜")) {
                            System.out.println("sweetness num out of range :"+dengji);
                        }
                    }
                    else {    
                    tablemes[tablenum].torder.addARecord(onum,dishName,dengji,portion,amount,type);
                    type = "普通";
                    dish = menu.searchDish(dishName);
                    if (dish != null) {
                        tablemes[tablenum].torder.records[orderNum].d = dish;
                        int a = tablemes[tablenum].torder.records[orderNum].getPrice();
                        if(tablemes[tablenum].discount>0)
                            System.out.println(tablemes[tablenum].torder.records[orderNum].orderNum + " " + dish.name + " " +a );
                        tablemes[tablenum].sumTprice += a;
                        tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].Tdiscount);
                    }
                    orderNum++;
                    }
                }
                
                else if(count == 6) {//代点特色菜
                    onum =Integer.parseInt(temp[0]);
                    int daitable = Integer.parseInt(temp[1]);
                    dishName =temp[2];
                    dengji = Integer.parseInt(temp[3]);
                    portion = Integer.parseInt(temp[4]);
                    amount = Integer.parseInt(temp[5]);
                    dish = menu.searchDish(dishName);
                    type = dish.type;
                    tablemes[daitable].torder.addARecord(onum,dishName,dengji,portion,amount,type);
                    type = "普通";
                    dish = menu.searchDish(dishName);
                    if (dish != null) {
                        tablemes[daitable].torder.records[orderNum].d = dish;
                        int a = tablemes[daitable].torder.records[orderNum].getPrice() * amount;
                        if(tablemes[daitable].discount>0)
                            System.out.println(tablemes[daitable].torder.records[orderNum].orderNum + " table " +tablenum+" pay for table "+daitable+ " " +a );
                        tablemes[tablenum].sumTprice += a;
                        tablemes[tablenum].disprice += Math.round( a*tablemes[tablenum].Tdiscount);
                    }
                }
                
                else if (count == 7) {//三个空格  ///桌子信息
                    if (temp[0].equals("table")) {//桌号
                        tablenum++;//跳过0;
                        orderNum = 0;
                        tablemes[tablenum] = new Table(tablenum,temp[3],temp[4]);
                        tablemes[tablenum].time.setTenDate(temp[5]);
                        tablemes[tablenum].time.setTenTime(temp[6]);
                        tablemes[tablenum].discount(tablemes[tablenum].time.getTimeofDay(), tablemes[tablenum].time.getDayOfWeek());
                        tablemes[tablenum].Tdiscount(tablemes[tablenum].time.getDayOfWeek());
                        if(tablemes[tablenum].discount>0)
                            System.out.println("table " + tablenum + ": ");
                    } 
                }
                else {
                    System.out.println("wrong format");
                    System.exit(0);
                }
                
            }
            for (i = 1; i <= tablenum; i++) {
                if(tablemes[i].Gettottalprice()==0)//输出价格等信息
                    System.exit(0);
              //输出 川菜+份数+辣度 等等等等等信息..............
                if(tablemes[i].discount>0) {
                if(tablemes[i].torder.chuancai != 0) {
                    System.out.print("川菜 "+tablemes[i].torder.chuancai+" "+tablemes[i].torder.word("川菜"));
                }
                if(tablemes[i].torder.jincai != 0) {
                    if(tablemes[i].torder.chuancai != 0) {
                        System.out.print(" 晋菜 "+tablemes[i].torder.jincai+" "+tablemes[i].torder.word("晋菜"));
                    }
                    else System.out.print("晋菜 "+tablemes[i].torder.jincai+" "+tablemes[i].torder.word("晋菜"));
                }
                if(tablemes[i].torder.zhecai != 0) {
                    if(tablemes[i].torder.chuancai != 0 || tablemes[i].torder.jincai != 0) {
                        System.out.println(" 浙菜 "+tablemes[i].torder.zhecai+" "+tablemes[i].torder.word("浙菜"));
                    }
                    else System.out.println("浙菜 "+tablemes[i].torder.zhecai+" "+tablemes[i].torder.word("浙菜"));
                }
                else System.out.printf("\n");
                }
                else System.out.printf("\n");
            }
            j=0;
            Customer customer = new Customer();
            for(i = 1; i<=tablenum; i++) {
                customer.Setcustomer(tablemes[i].name,tablemes[i].telnum,tablemes[i].disprice);
            }
            customer.paixu();
            for(i = 0;i<30;i++) {
//                System.out.println(customer.name[i]);
                if(customer.name[i]!=null) {
                    System.out.println(customer.name[i]+" "+customer.telnum[i]+" "+customer.sumprice[i]);
                }
            }
    }
}         

class Customer{
    String[] name = new String[30];
    String[] telnum = new String[30];
    int[] sumprice = new int[30];
    int i = 0;//保存用户个数
    int j = 0;
    int k = 1;//k=0时，用户重复；k=1时，新名字
    public void Setcustomer(String name, String telnum,int sumprice) {
        if(i==0) {//保存第一位用户
            this.name[i] = name;
            this.telnum[i] = telnum;
            this.sumprice[i] = sumprice;
            i++;
        }
        else {//
            for(j=0; j<i ;j++) {
                if(this.name[j].equals(name)) {//同一个用户
                    this.sumprice[j] += sumprice;//更改用户支付总价
                    k = 0;
                }
            }
            if(k == 1){//新用户
                this.name[i] = name;
                this.telnum[i] = telnum;
                this.sumprice[i] = sumprice;
                i++;
            }
        }
    }
    
    public void paixu() {
        int n = 0;
        int m = 0;
        String temp = "";
        int t = 0;
        for(n=0;n<i-1;n++) {
            for(m=n;m<i-1;m++) {
                if(this.name[m].charAt(0)>this.name[m+1].charAt(0)) {
                    temp=name[m];
                    name[m]=name[m+1];
                    name[m+1]=temp;
                    temp=telnum[m];
                    telnum[m]=telnum[m+1];
                    telnum[m+1]=temp;
                    t=sumprice[m];
                    sumprice[m]=sumprice[m+1];
                    sumprice[m+1]=t;
                }
            }
        }
    }
}
    


class Dish {//菜品类：对应菜谱上一道菜的信息。
    String name = "";//菜品名称
    int unit_price;//单价
    String type = "普通";//
    
    public Dish() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public Dish(String name, int unit_price, String type) {
        super();
        this.name = name;
        this.unit_price = unit_price;
        this.type = type;
    }
    
    public Dish(String name, int unit_price) {
        super();
        this.name = name;
        this.unit_price = unit_price;
    }
    
    public void resetDish(String name, int unit_price, String type) {
        this.name = name;
        this.unit_price = unit_price;
        this.type = type;
    }
    
    public int getPrice(int portion) {
        //计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份)
        int price = 0;
        if(portion == 1) {
            price = unit_price;
        }
        else if(portion == 2) {
            price = (int)(unit_price * 1.5 + 0.5);
        }
        else if(portion == 3) {
            price = (int)(unit_price * 2 + 0.5);
        }
        else System.out.println("portion out of range " + portion);
        return price;
    }
    public boolean validengji(String type, int dengji) {
        if(type.equals("川菜")&&dengji>=0&&dengji<=5) {
            return true;
        }
        else if(type.equals("晋菜")&&dengji>=0&&dengji<=4){
            return true;
        }
        else if(type.equals("浙菜")&&dengji>=0&&dengji<=3){
            return true;
        }
        return false;
    }
}

class Menu {//菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
    Dish[] dishs = new Dish[30];//普通菜品数组，保存所有非特价菜菜品信息
    static int i = 0;//dish个数
    public  Dish searchDish(String dishName){
        //根据菜名在菜谱中查找菜品信息，返回Dish对象.
        int j = 0;
        for(j=0;j<i;j++) {
            if(dishs[j]==null)
                System.out.println(dishName+" does not exist");
            if(dishs[j].name.equals(dishName)) {
                return dishs[j];//找到菜
            }
        }
        System.out.println(dishName+" does not exist");
        return null;//没找到，返回空
    }
    
    public void addDish(String dishName,int unit_price,String type){
        //添加一道菜品信息
        int m = 0;
        for(int j = 0; j<i ;j++) {
            if(dishs[j].name.equals(dishName)) {
                dishs[j].resetDish(dishName, unit_price, type);
                m++;
            }
        }
        if(m==0) {
            dishs[i] = new Dish(dishName, unit_price, type);
            i++;
        }
        
    }
}

class Order {//订单类：保存用户点的所有菜的信息。
    Record[] records = new Record[30];//保存订单上每一道的记录
    int k = 0;//records数组的元素个数
    //平均 口味（辣/酸/甜）度
    double avspicy = 0;
    double avsour = 0;
    double avsweet = 0;
    int chuancai = 0;
    int jincai = 0;
    int zhecai = 0;
    public Order() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Order(Record[] records) {
        super();
        this.records = records;
    }
    public Record[] getRecords() {
        return records;
    }
    public void setRecords(Record[] records) {
        this.records = records;
    }
    
    public int getTotalPrice() {
        //计算订单的总价
        int i = 0;
        int sum = 0;
        for(i=0;i<records.length;i++) {
            sum += records[i].getPrice();
        }
        return sum;
    }
    
    public String word(String type) {
        if(type.equals("川菜")) {
            int n = (int)Math.round(avspicy);
            switch(n) {
            case 0: return "不辣";
            case 1: return "微辣";
            case 2: return "稍辣";
            case 3: return "辣";
            case 4: return "很辣";
            case 5: return "爆辣";
            }
        }
        else if(type.equals("晋菜")) {
            int n = (int)Math.round(avsour);
            switch(n) {
            case 0: return "不酸";
            case 1: return "微酸";
            case 2: return "稍酸";
            case 3: return "酸";
            case 4: return "很酸";
            }
        }
        else if(type.equals("浙菜")) {
            int n = (int)Math.round(avsweet);
            switch(n) {
            case 0: return "不甜";
            case 1: return "微甜";
            case 2: return "稍甜";
            case 3: return "甜";
            }
        }
        return null;
    }
    
    public void addARecord(int orderNum,String dishName,int dengji,int portion,int amount, String type){
        //添加一条菜品信息到订单中。
        records[k] = new Record();
        records[k].d.name=dishName;
        records[k].orderNum=orderNum;
        records[k].dengji=dengji;
        records[k].portion=portion;
        records[k].amount=amount;
        k++;
        if(type.equals("川菜")) {
            if(avspicy == 0) {
                avspicy = dengji;
                chuancai = chuancai + amount ;
            }
            else {
                avspicy = (dengji*amount + avspicy * chuancai)/(amount+chuancai);
                chuancai = chuancai + amount;
            }
        }
        else if(type.equals("晋菜")) {
            if(avsour == 0) {
                avsour =dengji;
                jincai = jincai + amount ;
            }
            else {
                avsour = (dengji*amount + avsour * jincai)/(amount + jincai);
                jincai = jincai + amount;
            }
        }
        else if(type.equals("浙菜")){
            if(avsweet == 0) {
                avsweet =dengji;
                zhecai = zhecai + amount ;
            }
            else {
                avsweet = (dengji*amount + avsweet * zhecai)/(amount + zhecai);
                zhecai = zhecai + amount;
            }
            
        }
    }
    
    public int delARecordByOrderNum(int orderNum){
        //根据序号删除一条记录
         for(int i = 0; i < k; i++)
             if(records[i].orderNum == orderNum) 
                 return records[i].getPrice();
         System.out.println("delete error;");
         return 0;
    }
    

    public Record findRecordByNum(int orderNum){
        //根据序号查找一条记录
        int j = 0;
        for(j=0;j<k;j++) {
            if(records[j].orderNum==orderNum) {
                return records[j];
            }
        }
        return null;//没找到，返回空
    }
}

class Record {//点菜记录类：保存订单上的一道菜品记录
    int orderNum = 0;//序号
    Dish d = new Dish(" ",0);//菜品
    int dengji = 0;  //辣度/酸度/甜度
    int portion = 1; //份额（1/2/3代表小/中/大份）
    int amount = 1;  //菜品数量
    public int getPrice(){
        //计价，计算本条记录的价格
        return d.getPrice(portion)*amount;
    }
    
    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }
    public void setD(Dish d) {
        this.d = d;
    }
    public void setPortion(int portion) {
        this.portion = portion;
    }
    public void setAmount(int amount) {
        this.amount = amount;
    }
    
}

class Table {
    int tableNum = 0;//桌号
    int sumprice = 0;//一桌价格原价
    int sumTprice = 0;
    int disprice = 0;//一桌折扣价
    float discount = -1;
    float Tdiscount = -1;
    String name = "";//名字
    String telnum = "";//电话号码
    Order torder = new Order();
    Time time = new Time();
     
    public Table(int tableNum,String name,String telnum) {
        this.tableNum=tableNum;
        this.name = name;
        this.telnum = telnum;
    }
    int Gettottalprice(){
        if(discount>0){
            System.out.print("table " + tableNum + ": " + (sumprice+sumTprice) +" "+ disprice + " ");
            return 1;
        }else {
            System.out.println("table " + tableNum + " out of opening hours"); 
            return 0;
        }
    }
    void discount(int timeofday,int dayofweek){
        if((timeofday>=10.5*3600&&timeofday<=14.5*3600)&&(dayofweek>=1&&dayofweek<=5)) 
            discount =0.6F;
        else if((timeofday>=17*3600&&timeofday<=20.5*3600)&&(dayofweek>=1&&dayofweek<=5))
            discount =0.8F;
        else if((timeofday>=9.5*3600&&timeofday<=21.5*3600)&&(dayofweek==6||dayofweek==7))
            discount =1.0F;    
    }
    void Tdiscount(int dayofweek){
        if(dayofweek>=1&&dayofweek<=5) 
            Tdiscount =0.7F;
        else if(dayofweek==6||dayofweek==7)
            Tdiscount =1.0F;    
    } 
}


class Time {
    int [] TenTime;
    int [] TenDate;
    public void setTenDate(String DATE) {
        String[] strings=DATE.split("/");//字符型
        int[] TenDate=new int [3];
        for(int i=0;i<3;i++)
            TenDate[i]=Integer.parseInt(strings[i]);//Int
        this.TenDate = TenDate;
    }
    public void setTenTime(String TIME) {
        String[] strings=TIME.split("/");//字符型
        int[] TenTime=new int [3];
        for(int i=0;i<3;i++)
            TenTime[i]=Integer.parseInt(strings[i]);//Int
        this.TenTime = TenTime;
    }
    public int[] getTenTime() {
        return TenTime;
    }
    public int[] getTenDate() {
        return TenDate;
    }
    public int getDayOfWeek(){// 获取周第几天
        LocalDate date = LocalDate.of(TenDate[0],TenDate[1],TenDate[2]);//LocalDate
        return (date.getDayOfWeek().getValue());//调用LocalDate类中的getDayOfWeek方法，获取周第几天
    }
    
    public int getTimeofDay(){
        int tentime;
        tentime=TenTime[0]*3600+TenTime[1]*60+TenTime[2];
        return tentime;
    }

}

 

 

题目集八

课程成绩统计程序-1

题目信息如下：

7-1 课程成绩统计程序-1
分数 100
作者 蔡轲
单位 南昌航空大学
某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重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）成绩平均分只取整数部分，小数部分丢弃

参考类图：


image.png

输入样例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

首先阅读题干，分析题目需求，提取关键信息，这道题目给出了一个学校课程成绩的管理系统，题目包含以下几个部分：

1. 输入部分：包括课程和课程成绩两类信息。 课程信息包括课程名称、课程性质、考核方式三项，成绩信息包括学号、姓名、课程名称、平时成绩、期末成绩五项。 学校课程从性质上分为必修课和选修课，从考核方式上分为考试和考察。 成绩由平时成绩和期末成绩计算得出。

2. 输出部分：包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。 需要遍历所有的学生和课程信息，并按照要求输出所需的统计信息。

3. 异常情况：

   a.解析某个成绩信息时，课程名称不在已输入的课程列表中：输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

   b.解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配：输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

   c.解析某个课程信息时，输入的课程性质和课程的考核方式不匹配：输出：课程名称+" : course type & access mode mismatch"

   d.格式错误或其他信息：输出："wrong format"

   e.如果出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

我的编程思路如下：

1. 首先需要从输入中获取课程信息，对于每个课程信息，需要进行以下操作：

    a. 验证课程性质和考核方式是否匹配，如果不匹配，则直接输出错误信息并跳过该课程的信息。

    b. 将课程信息加入到课程列表中。

2. 接下来需要从输入中获取成绩信息，对于每个成绩信息，需要进行以下操作：

    a. 验证课程是否存在于课程列表中，如果不存在，则输出错误信息并跳过该成绩信息。

    b. 验证成绩数量和课程的考核方式是否匹配，如果不匹配，则输出错误信息并跳过该成绩信息。

    c. 对于考试和考察成绩信息，计算总成绩，对于实验成绩信息，计算平均成绩，将成绩信息加入到对应的学生、课程和班级的成绩列表中。

3. 遍历学生的成绩列表，计算每个学生的总成绩平均分，并将结果排序后输出。

4. 遍历课程列表，计算每个课程的平时成绩平均分、期末考试平均分和总成绩平均分，并将结果按照课程名称排序后输出。

5. 遍历班级的成绩列表，计算每个班级的总成绩平均分，并将结果排序后输出。

在实现编程时，我遇到以下问题：

1. 难以确定如何处理输入的数据：

输入数据需要进行解析和验证，而解析和验证的方式可能会影响程序的设计。例如，对于成绩信息的处理，需要对平时成绩和期末成绩进行权重计算，还需要根据考核方式进行不同的计算，这会增加程序的复杂度。

2. 难以处理输入数据中的错误和异常情况：

输入数据中存在各种错误和异常情况，例如，成绩超出范围、输入格式错误、成绩数量和考核方式不匹配等，这些情况都需要程序进行正确处理。在编写程序时需要考虑各种异常情况，并进行充分的测试和验证，以确保程序的正确性。

3. 如何进行数据的存储和计算：

程序需要对成绩数据进行存储和计算，并最终输出成绩统计数据。在存储和计算时，需要考虑哪些数据结构和算法最适合当前的问题，以及数据结构和算法的复杂度如何等因素。

4. 如何进行输出格式的控制：

程序需要按照指定的输出格式输出成绩统计数据，包括学生的总成绩平均分、单门课程的平时成绩平均分、期末考试平均分和总成绩平均分、班级的总成绩平均分等信息。输出格式的控制需要考虑各种细节问题，如空格、排序、小数点等，需要根据具体的规则进行设置。

5. 如何进行程序的测试和评估：

在完成程序编写后，我需要排查程序漏洞以通过各个测试点，但是我很难做到这一点，我没有充分的样例，需要自己琢磨出现的错误，自己写测试样例并尽可能覆盖更多的测试点。

总之，在编写程序时需要仔细考虑各种问题，并进行充分的测试和评估，以确保程序的正确性、健壮性和可扩展性。

根据参考类图，我创建了Choose类、Classroom类、Course类、Score类、Student类，其中，Choose类是程序的主体实现类，由course、student、score组成，以进行数据间的连接。班级由学生组成。

在主类Main中，首先通过while循环语句对输入的数据一行一行的进行处理，具体操作方式为：为读取的一行字符串去除空格进行分隔，并存入一个字符串数组temp[]，通过判断字符串数组temp[]的长度count判断读取的语句要实现的功能，以进行相应操作。如输入课程信息时，格式为“java 必修 考试”，如此count便等于3。需要注意的是，如果课程性质是必修课，考核方式可以没有，因此当count=2时也有可能是添加课程信息。

此部分代码如下：

if(count == 3 || (count==2&&temp[1].equals("必修"))){//添加课程信息
                if(count == 3){
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],temp[2]));
                    }
                    else System.out.println("wrong format");
                }
                else {
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],"考试"));
                    }
                    else System.out.println("wrong format");
                }
            }

同理，便可以处理其他数据信息。由于录入的信息有格式要求，为方便起见统一使用正则表达式进行数据的合法性判断，具体如下：

if(count == 5){
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")&&temp[4].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$"))//姓名与课程名
                    {
                        choose.addScore(new Score(st));
                    }
                    else System.out.println("wrong format");
                }

只有数据合法时，才会录入课程成绩信息。

对于信息的录入，首先在主方法中创建Choose类对象，

Choose类中具有以下属性：

private ArrayList<Course> courses = new ArrayList<>();
private ArrayList<Score> scores = new ArrayList<>();
private ArrayList<Student> students = new ArrayList<>();
public ArrayList<Classroom> classrooms = new ArrayList<>();

分别用来存放不同类型的数据

Choose类中具有方法

public void addCourse(Course course) //用于添加课程信息

public void addScore(Score score) //用于添加课程成绩信息

 对于addCourse方法，首先需要判断想要添加的course对象是否合法（课程性质与考核形式不冲突，如必修课的考核形式一定是考试），之后要判断是否存在课程重名的情况，如果想要添加的course对象已经存在于choose类的存放course的list中，则不添重复加此课程。反之，添加进courses链中。

对于addScore方法，于addCourse方法类似，不过由于课程成绩信息牵涉到的信息过多（学生信息、课程成绩、班级等）因此，需要具备更复杂的逻辑关系将各个数据进行存储处理。如需要判断班级是否是新的班级，若不是，需要将学生信息添加到已经存在的班级中；需要判断学生是否是新学生，若不是，需要将成绩信息存在此学生之前创建的对象中，而不是新建一个对象；以及需要判断课程是否存在，不存在时需要输出异常语句，但此条信息中的学生信息、班级信息依旧需要录入，只不过没有成绩。

之后要对处理后的信息进行输出，Choose类中有如下方法：

public void getStuScore()//输出学生所有课程总成绩平均分

public void getCouScore()//输出课程成绩信息

public void getClaScore()//输出班级平均分信息

 由于输出有排序限制：学生课程总成绩平均分按学号从低到高排序输出、单门课程成绩按课程名称的字符顺序输出、班级成绩信息按班级由低到高顺序输出。

因此需要在遍历数据信息输出前，将存储的数据进行排序。在Choose类中编写了sortStu、sortCla方法将信息进行排序。为了单门课程成绩按字符顺序输出，我在Course类实现Compara接口，并重写compareTo方法，如下：

@Override
public int compareTo(Course o) {
Comparator<Object> c = Collator.getInstance(Locale.CHINA);
return ((Collator) c).compare(this.courseName,o.courseName);
}

此题整体逻辑不算复杂，但是处理起来还是很棘手，有各种各样的异常情况需要分析处理，写着写着容易将自己绕晕。

此题完整代码如下：

import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Choose choose = new Choose();
        while(true){
            String st = scanner.nextLine();
            String[] temp = st.split(" ");
            int count = temp.length;
            if(st.equals("end"))
                break;
            if(count == 3 || (count==2&&temp[1].equals("必修"))){//添加课程信息
                if(count == 3){
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],temp[2]));
                    }
                    else System.out.println("wrong format");
                }
                else {
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],"考试"));
                    }
                    else System.out.println("wrong format");
                }
            }
            if(count == 5 || count == 4){//添加课程成绩信息
                if(count == 5){
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")&&temp[4].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$"))//姓名与课程名
                    {
                        choose.addScore(new Score(st));
                    }
                    else System.out.println("wrong format");
                }
                else{
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$")){
                        choose.addScore(new Score(st));
                    }
                    else System.out.println("wrong format");
                }
            }
        }
        choose.getStuScore();
        choose.getCouScore();
        choose.getClaScore();
    }
}

class Choose {
    private ArrayList<Course> courses = new ArrayList<>();
    private ArrayList<Score> scores = new ArrayList<>();
    private ArrayList<Student> students = new ArrayList<>();
    public ArrayList<Classroom> classrooms = new ArrayList<>();
    int classnum = 0;
    public void addCourse(Course course) {//添加课程信息
        if (course.getNature().equals("必修")) {//课程性质考试形式冲突
            if (!course.getEvaluation_mode().equals("考试")) {
                System.out.println(course.getCourseName() + " : course type & access mode mismatch");
                return;
            }
        }
        if (!this.courses.isEmpty()) {
            int n = 0;
            for (Course c : courses) {
                if (c.getCourseName().equals(course.getCourseName())) {//课程重名
                    n++;
                }
            }
            if(n==0){
                courses.add(course);
            }
        }
        else courses.add(course);
    }
    public void addScore(Score score) {//添加课程成绩信息
        if (!this.courses.isEmpty()) {
            int n = 0;//判断课程是否存在
            for (Course c : courses) {
                if (c.getCourseName().equals(score.getCourseName())) {
                    n++;//课程存在
                    if (c.getEvaluation_mode().equals("考试") && (score.getUsual_score() == 0 || score.getFinal_score() == 0)) {//成绩与考核方式不匹配
                        System.out.println(score.getStudentId() + " " + score.getStudentName() + " : access mode mismatch");
                        int xx = 0;
                        students.add(new Student(score.getStudentName(), score.getStudentId()));
                        for (Classroom cl : classrooms) {
                            if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                xx++;
                                break;
                            }
                        }
                        if (xx == 0) {//新班级
                            classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                        }
                    }
                    else if(c.getEvaluation_mode().equals("考察")&&(score.getUsual_score()!=0)){
                        System.out.println("wrong format");
                    }
                    else {
                        scores.add(score);
                        c.addScore(score.getUsual_score(), score.getFinal_score(), score.thescore());


                        int k = 0;//判断是不是新学生
                        for (Student s : students) {
                            if (s.getID().equals(score.getStudentId())) {//之前就存在这个学生
                                k = 1;
                                s.addScores(score);
                                int yy = 0;
                                for (Classroom cl : classrooms) {
                                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                        cl.score += score.thescore();
                                        cl.k++;
                                        yy++;
                                        break;
                                    }
                                }
                            }
                        }
                        if (k == 0) {//新学生
                            int xx = 0;
                            students.add(new Student(score.getStudentName(), score.getStudentId(), score));
                            for (Classroom cl : classrooms) {
                                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                    cl.score += score.thescore();
                                    cl.k++;
                                    xx++;
                                    break;
                                }
                            }
                            if (xx == 0) {//新班级
                                classrooms.add(new Classroom(score.thescore(), score.getStudentId().substring(0, 6)));
                                classnum++;
                            }
                        }




                    }
                }
            }
            if (n == 0) {//课程不存在
                System.out.println(score.getCourseName() + " does not exist");

                int xx = 0;
                students.add(new Student(score.getStudentName(), score.getStudentId()));
                for (Classroom cl : classrooms) {
                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                        xx++;
                        break;
                    }
                }
                if (xx == 0) {//新班级
                    classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                }
            }

        }
        else{
            System.out.println(score.getCourseName() + " does not exist");

            int xx = 0;
            students.add(new Student(score.getStudentName(), score.getStudentId()));
            for (Classroom cl : classrooms) {
                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                    xx++;
                    break;
                }
            }
            if (xx == 0) {//新班级
                classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
            }
        }
    }

    public void getStuScore(){//学生所有课程总成绩平均分
        sortStu();
        for(Student s : students){
            if(s.getPjf() == 0){
                System.out.println(s.getID()+" "+s.getName() + " did not take any exams");
                return;
            }
            else {
                System.out.println(s.getID() +" "+s.getName()+ " "+s.getPjf());
            }
        }
    }

    public void getCouScore(){
        Collections.sort(courses);
        for(Course c: courses){
            if(c.getScore()==0){
                System.out.println(c.getCourseName()+" has no grades yet");
            }
            else{
                if(c.getUsualscore()!=0){
                    System.out.println(c.getCourseName()+" "+c.getUsualscore()/c.getK()+" "+c.getFinalscore()/c.getK()+" "+c.getScore()/c.getK());
                }
                else{
                    System.out.println(c.getCourseName()+" "+c.getFinalscore()/c.getK()+" "+c.getScore()/c.getK());
                }
            }
        }
    }
    public void getClaScore(){//班级平均分
        sortCla();
        for(Classroom c:classrooms){
            c.getCScore();
        }
    }

    public void sortStu(){
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getID().compareTo(o2.getID());
            }
        });
    }

    public void sortCla(){
        Collections.sort(classrooms, new Comparator<Classroom>() {
            @Override
            public int compare(Classroom o1, Classroom o2) {
                return o1.cID.compareTo(o2.cID);
            }
        });
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }

}

class Course implements Comparable<Course>{
    private String courseName ;  //课程名称
    private String nature = "必修";   //课程性质
    private String access_mode = "考试";  //考核模式
    private int score = 0;
    private int usualscore = 0;
    private int finalscore = 0;
    private int k = 0;
    private int c = 0;
    //构造方法
    public Course() {

    }
    public Course(String courseName,String nature,String access_mode) {
        this.courseName = courseName;
        this.nature = nature;
        this.access_mode = access_mode;
        c++;
    }
    public void addScore(int us,int fs,int s){
        score += s;
        usualscore+= us;
        finalscore+= fs;
        k++;
    }
//getset方法

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
    public String getNature() {
        return nature;
    }
    public void setNature(String nature) {
        this.nature = nature;
    }
    public String getEvaluation_mode() {
        return access_mode;
    }
    public void setEvaluation_mode(String evaluation_mode) {
        this.access_mode = evaluation_mode;
    }

    public String getAccess_mode() {
        return access_mode;
    }

    public void setAccess_mode(String access_mode) {
        this.access_mode = access_mode;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getUsualscore() {
        return usualscore;
    }

    public void setUsualscore(int usualscore) {
        this.usualscore = usualscore;
    }

    public int getFinalscore() {
        return finalscore;
    }

    public void setFinalscore(int finalscore) {
        this.finalscore = finalscore;
    }

    public int getK() {
        return k;
    }

    public void setK(int k) {
        this.k = k;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> c = Collator.getInstance(Locale.CHINA);
        return ((Collator) c).compare(this.courseName,o.courseName);
    }
}

class Score{
    private String studentId;
    private String studentName;
    private String courseName;
    private int usual_score;//平时成绩
    private int final_score;//期末成绩
    public Score(String line) {
        String[] parts = line.split(" ");
        studentId = parts[0];
        studentName = parts[1];
        courseName = parts[2];
        usual_score = parts.length > 4 ? Integer.parseInt(parts[3]) : 0;
        final_score = Integer.parseInt(parts[parts.length - 1]);
    }

    public int thescore(){
        if(getUsual_score()==0)
            return getFinal_score();
        else return (int) (getUsual_score()*0.3+getFinal_score()*0.7);
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public int getUsual_score() {
        return usual_score;
    }

    public void setUsual_score(int usual_score) {
        this.usual_score = usual_score;
    }

    public int getFinal_score() {
        return final_score;
    }

    public void setFinal_score(int final_score) {
        this.final_score = final_score;
    }
}
class Student{
    private String name;
    private String ID;
    private ArrayList<Score> scores = new ArrayList<>();
    public Student(String name, String ID, Score scores) {
        this.name = name;
        this.ID = ID;
        this.scores.add(scores);
    }
    public Student(String name,String ID){
        this.name = name;
        this.ID = ID;
    }
    public void addScores(Score scores){
        this.scores.add(scores);
    }
    public int getPjf(){
        int pjf = 0;
        for(Score s : scores){
            pjf += s.thescore();
        }
        if(!scores.isEmpty())
            pjf  = pjf/ scores.size();
        return pjf;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }
}

class Classroom{
    public int score = 0;
    public String cID;
    public int k = 0;

    public Classroom(int score, String cID) {
        this.score = score;
        this.cID = cID;
        if(score!=0){
            k++;
        }
    }

    public void getCScore(){
        if( k == 0){
            System.out.println(cID+" has no grades yet");
        }
        else{
            System.out.println(cID+" "+(int)(score/k));
        }
    }
}

 

 

题目集九

统计Java程序中关键词的出现次数

题目信息如下：

7-1 统计Java程序中关键词的出现次数
分数 100
作者 段喜龙
单位 南昌航空大学
编写程序统计一个输入的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
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

首先分析题目，程序需要从标准输入读入Java源码，统计其中关键字的出现次数，并按照关键字升序排列输出结果。

我使用while循环语句读取每一行的代码信息，使用Java的正则表达式库实现关键字的匹配，使用Java集合框架中的Map实现储存关键字计数。在代码实现中，程序忽略了单行注释和多行注释中的关键字的统计，并且在遇到字符串时也忽略了其中的关键字的统计。同时程序在遇到“exit”字符串时结束程序的运行，妥善处理了输入非法的情况，最终输出关键字及数量排序后的统计数据。

代码String regex = "\\b" + keyword + "\\b"用来匹配Java源代码中的关键字，`\b`表示一个单词的边界。当keyword的值为“while”时，该正则表达式就是`\bwhile\b`，它可以很好地与Java源代码中的“while”单词进行匹配，但不会误匹配“while”的变种，例如“whiles”、“inwhile”等字符串。

为了实现对Java源码每一行中的关键字的匹配和计数。

我首先使用Java正则表达式中的Pattern类的`compile()`方法，将定义好的关键字正则表达式`regex`编译成Pattern模式。然后使用该模式构建一个matcher对象，这个对象将用于检查类似`line`这样的Java代码行是否包含关键字。

接下来使用Matcher的`find()`方法在`line`中查找符合正则表达式的子串。如果`find()`返回`true`，则说明这一行代码包含至少一个关键字，获取该匹配串并存为`matchedKeyword`。然后使用`keywordCountMap`统计`matchedKeyword`的出现次数。如果`matchedKeyword`已经存在于`keywordCountMap`中，则获取它的计数值并加1；否则默认计数为0后加1。最后将更新后的计数值写回Map中。

此外，我使用正则表达式和String类中的replace方法去除了有干扰的代码块：

line = line.replaceAll("//.*","");用来将出现在行中间的单行注释之后的内容替换为空

 line = line.replaceAll("\".*?\"","");用来将字符串内的内容替换为空，这样先前的内容就不会被统计。

具体代码如下：

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        String[] KEYWORDS = {
        "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char","class", "const", "continue", "default", "do", "double", "else", "enum",
        "extends", "final", "finally", "float", "for", "if", "goto", "implements","import", "instanceof", "int", "interface", "long", "native", "new", "package",
        "private", "protected", "public", "return", "short", "static", "strictfp","super", "switch", "synchronized", "this", "throw", "throws", "transient",
        "try", "void", "volatile", "while","true","false","null"
    };
        Map<String, Integer> keywordCountMap = new TreeMap<>();//存放keyword-count键值对，默认按键的升序排序
        Scanner scanner = new Scanner(System.in);
        String line;
        int linecount = 0;//判断行数
        boolean isCodeRegion = true;//判断是否是代码区
        while (true) {
            line = scanner.nextLine();
            if (line.equals("exit")) {
                break;
            }
            linecount++;
            line = line.replaceAll("//.*","");
            line = line.replaceAll("\".*?\"","");
            line = line.replaceAll("=","1");
            if (line.trim().startsWith("//")) {
                continue;//单行注释，直接跳过此行
            }
            if (line.trim().startsWith("/*")) {
                isCodeRegion = false;   //多行注释开头，接下来都不是代码区
            }
            if (isCodeRegion) {
                for (String keyword : KEYWORDS) {
                    String regex = "\\b" + keyword + "\\b"; // 使用正则表达式匹配单词边界
                    Matcher matcher = Pattern.compile(regex).matcher(line);//检查line是否包含关键字
                    while (matcher.find()) {//代码包含至少一个关键字
                        String matchedKeyword = matcher.group();//获取该匹配串并存为matchedKeyword
                        int count = keywordCountMap.getOrDefault(matchedKeyword, 0);//取出matchedKeyword对应的值，没有则赋0
                        keywordCountMap.put(matchedKeyword, count + 1);//count+1
                    }
                }
            }
            if (line.trim().endsWith("*/")) {
                isCodeRegion = true;   //多行注释结尾，接下来是代码区
            }
        }
        if(linecount==0){
            System.out.println("Wrong Format");
            return;
        }
        if (keywordCountMap.isEmpty()) {//没有统计数据时输出为空
            System.out.println("");
            return;
        }
        for (String keyword : keywordCountMap.keySet()) {
            int count = keywordCountMap.get(keyword);
            System.out.println(count + "\t" + keyword);
        }
    }
}

 

 

题目集十

课程成绩统计程序-2

题目信息如下：

7-3 课程成绩统计程序-2
分数 60
作者 蔡轲
单位 南昌航空大学
课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：


e724fa4193aa9ee32e78a68cd96fd6df_22401e04-c501-4b28-bb65-dabe39d374e7.png

输入样例1:
在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 4 70 80 90
end
输出样例1:
在这里给出相应的输出。例如：

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet
输入样例2:
在这里给出一组输入。例如：

java 实验 实验
20201103 张三 java 3 70 80 90
end
输出样例2:
在这里给出相应的输出。例如：

wrong format
java has no grades yet
输入样例3:
在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 3 70 80 90 100
end
输出样例3:
在这里给出相应的输出。例如：

java : course type & access mode mismatch
wrong format
输入样例4:
在这里给出一组输入。例如：

java 必修 实验
20201103 张三 java 4 70 80 90 105
end
输出样例4:
在这里给出相应的输出。例如：

java : course type & access mode mismatch
wrong format

输入样例5:
在这里给出一组输入。例如：

java 选修 考察
C语言 选修 考察
java实验 实验 实验
编译原理 必修 考试
20201101 王五 C语言 76
20201216 李四 C语言 78
20201307 张少军 编译原理 82 84
20201103 张三 java实验 4 70 80 90 100
20201118 郑觉先 java 80
20201328 刘和宇 java 77
20201220 朱重九 java实验 4 60 60 80 80
20201132 王萍 C语言 40
20201302 李梦涵 C语言 68
20201325 崔瑾 编译原理 80 84
20201213 黄红 java 82
20201209 赵仙芝 java 76
end
输出样例5:
在这里给出相应的输出。例如：

20201101 王五 76
20201103 张三 85
20201118 郑觉先 80
20201132 王萍 40
20201209 赵仙芝 76
20201213 黄红 82
20201216 李四 78
20201220 朱重九 70
20201302 李梦涵 68
20201307 张少军 83
20201325 崔瑾 82
20201328 刘和宇 77
C语言 65 65
java 78 78
java实验 77
编译原理 81 84 82
202011 70
202012 76
202013 77

本题是课程成绩统计程序的迭代，有了上一次的基础，这次写起来便轻松很多。

首先分析题目，本次程序主要是在第一次的基础上增加了实验课，实验课的考核方式也一定为实验，规定实验次数至少四次，不超过9次。

这次迭代并没有增加太多的东西，只需要在主函数的while语句读取输入信息时，增加字符串长度符合实验课信息长度的情况即可，其他科目通过识别考核方式进行权重评分，而实验课则是多次实验的平均分，相比起来其实更好处理，只需要在录入实验课成绩时累加成绩，最后再除以做实验的次数。

此次迭代难度不大，其他部分的详细编程过程见课程成绩统计程序-1中介绍。

完成代码如下：

import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Choose choose = new Choose();
        while(true){
            String st = scanner.nextLine();
            String[] temp = st.split(" ");
            int count = temp.length;
            if(st.equals("end"))
                break;
            if(count == 3 || (count==2&&temp[1].equals("必修"))){//添加课程信息
                if(count == 3){
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],temp[2]));
                    }
                    else System.out.println("wrong format");
                }
                else {
                    if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                        choose.addCourse(new Course(temp[0],temp[1],"考试"));
                    }
                    else System.out.println("wrong format");
                }
            }
            if(count == 5 || count == 4){//添加课程成绩信息
                if(count == 5){
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")&&temp[4].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$"))//姓名与课程名
                    {
                        choose.addScore(new Score(st));
                    }
                    else System.out.println("wrong format");
                }
                else{
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$")){
                        choose.addScore(new Score(st));
                    }
                    else System.out.println("wrong format");
                }
            }
            else if(count >5){//添加实验课课程成绩
                int k = 0;
                if(temp[0].matches("\\d{8}")//ID
                        &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$")){//姓名与课程名
                    for(int i = 4; i<count;i++){
                        if(!temp[i].matches("^([1-9]\\d?|100|0)$")){
                            System.out.println("wrong format");
                            k++;
                            break;
                        }
                    }
                    if(k==0){
                        choose.addScore(new Score(st));
                    }
                }
                else System.out.println("wrong format");
            }
        }
        choose.getStuScore();
        choose.getCouScore();
        choose.getClaScore();
    }
}

class Choose {
    private ArrayList<Course> courses = new ArrayList<>();
    private ArrayList<Score> scores = new ArrayList<>();
    private ArrayList<Student> students = new ArrayList<>();
    public ArrayList<Classroom> classrooms = new ArrayList<>();
    int classnum = 0;
    public void addCourse(Course course) {//添加课程信息
        if (course.getNature().equals("必修")) {//课程性质考试形式冲突
            if (!course.getEvaluation_mode().equals("考试")) {
                System.out.println(course.getCourseName() + " : course type & access mode mismatch");
                return;
            }
        }
        if (!this.courses.isEmpty()) {
            int n = 0;
            for (Course c : courses) {
                if (c.getCourseName().equals(course.getCourseName())) {//课程重名
                    n++;
                }
            }
            if(n==0){
                courses.add(course);
            }
        }
        else courses.add(course);
    }
    public void addScore(Score score) {//添加课程成绩信息
        if (!this.courses.isEmpty()) {
            int n = 0;//判断课程是否存在
            for (Course c : courses) {
                if (c.getCourseName().equals(score.getCourseName())) {
                    n++;//课程存在
                    if ((c.getEvaluation_mode().equals("考试") && (score.getUsual_score() == 0 || score.getFinal_score() == 0))
                            ||(c.getEvaluation_mode().equals("考察")&&(score.getUsual_score()!=0))) {
                        //成绩与考核方式不匹配
                        System.out.println(score.getStudentId() + " " + score.getStudentName() + " : access mode mismatch");
                        int xx = 0;
                        students.add(new Student(score.getStudentName(), score.getStudentId()));
                        for (Classroom cl : classrooms) {
                            if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                xx++;
                                break;
                            }
                        }
                        if (xx == 0) {//新班级
                            classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                        }
                    }

//                   else if(c.getEvaluation_mode().equals("考察")&&(score.getUsual_score()!=0)){
//                       System.out.println("wrong format");
//                   }
                    else {
                        scores.add(score);
//                       if(c.getEvaluation_mode()=="实验"&&c.getNature()=="实验"){
//                           c.addShiYanScore(score.getShiyan_score());
//                       }
//                       else{
                        c.addScore(score.getUsual_score(), score.getFinal_score(), score.thescore());
//                       }

                        int k = 0;//判断是不是新学生
                        for (Student s : students) {
                            if (s.getID().equals(score.getStudentId())) {//之前就存在这个学生
                                k = 1;
                                s.addScores(score);
                                int yy = 0;
                                for (Classroom cl : classrooms) {
                                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                        cl.score += score.thescore();
                                        cl.k++;
                                        yy++;
                                        break;
                                    }
                                }
                            }
                        }
                        if (k == 0) {//新学生
                            int xx = 0;
                            students.add(new Student(score.getStudentName(), score.getStudentId(), score));
                            for (Classroom cl : classrooms) {
                                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                    cl.score += score.thescore();
                                    cl.k++;
                                    xx++;
                                    break;
                                }
                            }
                            if (xx == 0) {//新班级
                                classrooms.add(new Classroom(score.thescore(), score.getStudentId().substring(0, 6)));
                                classnum++;
                            }
                        }




                    }
                }
            }
            if (n == 0) {//课程不存在
                System.out.println(score.getCourseName() + " does not exist");

                int xx = 0;
                students.add(new Student(score.getStudentName(), score.getStudentId()));
                for (Classroom cl : classrooms) {
                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                        xx++;
                        break;
                    }
                }
                if (xx == 0) {//新班级
                    classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                }
            }

        }
        else{
            System.out.println(score.getCourseName() + " does not exist");

            int xx = 0;
            students.add(new Student(score.getStudentName(), score.getStudentId()));
            for (Classroom cl : classrooms) {
                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                    xx++;
                    break;
                }
            }
            if (xx == 0) {//新班级
                classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
            }
        }
    }

    public void getStuScore(){//学生所有课程总成绩平均分
        sortStu();
        for(Student s : students){
            if(s.getPjf() == 0){
                System.out.println(s.getID()+" "+s.getName() + " did not take any exams");

            }
            else {
                System.out.println(s.getID() +" "+s.getName()+ " "+s.getPjf());
            }
        }
    }

    public void getCouScore(){
        Collections.sort(courses);
        for(Course c: courses){
            if(c.getScore()==0){
                System.out.println(c.getCourseName()+" has no grades yet");
            }
            else{
                if(c.getEvaluation_mode().equals("实验")){
                    System.out.println(c.getCourseName()+" "+c.getScore()/c.getK());
                }
                else if(c.getUsualscore()==0){
                    System.out.println(c.getCourseName()+" "+c.getFinalscore()/c.getK()+" "+c.getScore()/c.getK());
                }
                else if(c.getUsualscore()!=-1&&c.getUsualscore()!=0&&c.getFinalscore()!=-1){
                    System.out.println(c.getCourseName()+" "+c.getUsualscore()/c.getK()+" "+c.getFinalscore()/c.getK()+" "+c.getScore()/c.getK());
                }
            }
        }
    }
    public void getClaScore(){//班级平均分
        sortCla();
        for(Classroom c:classrooms){
            c.getCScore();
        }
    }

    public void sortStu(){
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getID().compareTo(o2.getID());
            }
        });
    }

    public void sortCla(){
        Collections.sort(classrooms, new Comparator<Classroom>() {
            @Override
            public int compare(Classroom o1, Classroom o2) {
                return o1.cID.compareTo(o2.cID);
            }
        });
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }

}

class Course implements Comparable<Course>{
    private String courseName ;  //课程名称
    private String nature = "必修";   //课程性质
    private String access_mode = "考试";  //考核模式
    private int score = 0;
    private int usualscore = 0;
    private int finalscore = 0;
    private int k = 0;
    private int c = 0;
    //构造方法
    public Course() {

    }
    public Course(String courseName,String nature,String access_mode) {
        this.courseName = courseName;
        this.nature = nature;
        this.access_mode = access_mode;
        c++;
    }
    public void addScore(int us,int fs,int s){
        score += s;
        usualscore+= us;
        finalscore+= fs;
        k++;
    }
    public void addShiYanScore(int score){
        score += score;
        k++;
    }
//getset方法

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
    public String getNature() {
        return nature;
    }
    public void setNature(String nature) {
        this.nature = nature;
    }
    public String getEvaluation_mode() {
        return access_mode;
    }
    public void setEvaluation_mode(String evaluation_mode) {
        this.access_mode = evaluation_mode;
    }

    public String getAccess_mode() {
        return access_mode;
    }

    public void setAccess_mode(String access_mode) {
        this.access_mode = access_mode;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getUsualscore() {
        return usualscore;
    }

    public void setUsualscore(int usualscore) {
        this.usualscore = usualscore;
    }

    public int getFinalscore() {
        return finalscore;
    }

    public void setFinalscore(int finalscore) {
        this.finalscore = finalscore;
    }

    public int getK() {
        return k;
    }

    public void setK(int k) {
        this.k = k;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> c = Collator.getInstance(Locale.CHINA);
        return ((Collator) c).compare(this.courseName,o.courseName);
    }
}

class Score{
    private String studentId;
    private String studentName;
    private String courseName;
    private int usual_score;//平时成绩
    private int final_score;//期末成绩
    private int shiyan_time = 0;
    private int shiyan_score;//实验平均分
    public Score(String line) {
        String[] parts = line.split(" ");
        studentId = parts[0];
        studentName = parts[1];
        courseName = parts[2];
        if(parts.length<=5){
            usual_score = parts.length > 4 ? Integer.parseInt(parts[3]) : 0;
            final_score = Integer.parseInt(parts[parts.length - 1]);
        }
        else{
            usual_score = -1;
            final_score = -1;
            shiyan_time = Integer.parseInt(parts[3]);
            if(shiyan_time+4 == parts.length){
                for(int i = 0; i<shiyan_time;i++){
                    shiyan_score += Integer.parseInt(parts[i+4]);
                }
                shiyan_score = shiyan_score/shiyan_time;
            }
            else{
                System.out.println(studentId+" "+studentName+" : access mode mismatch");
            }
        }



    }

    public int thescore(){
        if(shiyan_time!=0){
            return shiyan_score;
        }
        else if(getUsual_score()==0)
            return getFinal_score();
        else return (int) (getUsual_score()*0.3+getFinal_score()*0.7);
    }

    public int getShiyan_score() {
        return shiyan_score;
    }

    public int getShiyan_time() {
        return shiyan_time;
    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public int getUsual_score() {
        return usual_score;
    }

    public void setUsual_score(int usual_score) {
        this.usual_score = usual_score;
    }

    public int getFinal_score() {
        return final_score;
    }

    public void setFinal_score(int final_score) {
        this.final_score = final_score;
    }
}
class Student{
    private String name;
    private String ID;
    private ArrayList<Score> scores = new ArrayList<>();
    public Student(String name, String ID, Score scores) {
        this.name = name;
        this.ID = ID;
        this.scores.add(scores);
    }
    public Student(String name,String ID){
        this.name = name;
        this.ID = ID;
    }
    public void addScores(Score scores){
        this.scores.add(scores);
    }
    public int getPjf(){
        int pjf = 0;
        for(Score s : scores){
            pjf += s.thescore();
        }
        if(!scores.isEmpty())
            pjf  = pjf/ scores.size();
        return pjf;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }
    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }
}
class Classroom{
    public int score = 0;
    public String cID;
    public int k = 0;

    public Classroom(int score, String cID) {
        this.score = score;
        this.cID = cID;
        if(score!=0){
            k++;
        }
    }

    public void getCScore(){
        if( k == 0){
            System.out.println(cID+" has no grades yet");
        }
        else{
            System.out.println(cID+" "+(int)(score/k));
        }
    }
}

 

 

题目集十一

课程成绩统计程序-3

题目信息如下：

7-2 课程成绩统计程序-3
分数 64
作者 蔡轲
单位 南昌航空大学
课程成绩统计程序-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）成绩平均分只取整数部分，小数部分丢弃

参考类图（与第一次相同，其余内容自行补充）：

fdada4ca193119ee30531ab82ffebbfa_9dbcf4e8-1627-4cf6-8764-cccf44947e2a.png

输入样例1:
在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
end
输出样例1:
在这里给出相应的输出。例如：

java has no grades yet
输入样例2:
在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2
end
输出样例2:
在这里给出相应的输出。例如：

java : number of scores does not match
输入样例3:
在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.1
end
输出样例3:
在这里给出相应的输出。例如：

java : weight value error
输入样例4:
在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100
end
输出样例4:
在这里给出相应的输出。例如：

20201116 张三 86
java 86
202011 86
输入样例5:
在这里给出一组输入。例如：

java 实验 实验 4 0.2 0.3 0.2 0.3
20201116 张三 java 70 80 90 100 80
end
输出样例5:
在这里给出相应的输出。例如：

20201116 张三 : access mode mismatch
20201116 张三 did not take any exams
java has no grades yet
202011 has no grades yet

本次迭代修改了计算总成绩的方式，并且要求修改类结构，将继承关系改为组合关系。成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

为了实现迭代功能，我新建了ItemScore分项成绩类，此类中包含两个属性：grade分项成绩分值和weight成绩权重，以及一个方法getGradeByWeight（）用来根据权重计算得分。

修改Score类中部分代码，使得Score类组合ItemScore类。首先，Score类中包含属性：private List<ItemScore> itemList = new ArrayList<>();  // 分项成绩列表，并在Score类中添加方法getTotalGrade()用来计算总成绩。

public double getTotalGrade() { // 计算总成绩
double total = 0;
for (ItemScore item : itemList) {
total += item.getGradeByWeight();
}
return total;
}

由于新增了权重值的概念，在录入课程信息和课程成绩信息时在主函数匹配的字符串长度需要进行改变，并且在录入课程信息时要录入权重值信息，由于录入课程信息是通过Choose类的addCourse（Course course）方法，因此我的改进思路是在Course类中再增加课程权重的List链并改变Course的构造方法，多添加传进去的参数，使之变成：public Course(String courseName,String nature,String access_mode,List<Double> weight)，这样便可以将成绩权重作为有序的链存在Course中。录入课程成绩信息时，使用Score类的List<ItemScore> Itemlist属性对成绩进行权重计算，通过getTotalGrade()方法遍历 itemlist 进行计算总成绩。

public Score(String line,List<Double> weight) {
String[] parts = line.split("");
studentId = parts[0];
studentName = parts[1];
courseName = parts[2];
if(parts.length<=5){
int u = parts.length > 4 ? Integer.parseInt(parts[3]) : 0;
itemList.get(0).setWeight(weight.get(0));
itemList.get(0).setGrade(u);
int f = Integer.parseInt(parts[parts.length - 1]);
itemList.get(1).setWeight(weight.get(1));
itemList.get(1).setGrade(f);
}
else{
int j = 0;
if(parts.length==weight.size()+3){
for(int i=3;i< parts.length;i++){
itemList.add(new ItemScore());
itemList.get(j).setWeight(weight.get(j));
itemList.get(j).setGrade(Integer.parseInt(parts[i]));
j++;
}
} else {
System.out.println(studentId+" "+studentName+" : access mode mismatch");
}
}
}

程序完整代码如下:

import java.text.Collator;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Choose choose = new Choose();
        while(true){
            String st = scanner.nextLine();
            String[] temp = st.split(" ");
            int count = temp.length;
            if(st.equals("end"))
                break;
            if(temp[1].equals("选修")||temp[1].equals("必修")||temp[1].equals("实验")){//添加课程信息
                if(temp[1].matches("^[\\w\\W]{1,10}$") ){//课程名
                    int n = Integer.parseInt(temp[3]);
                    if((n+4)!=count){
                        System.out.println(temp[0]+" : number of scores does not match");
                        return;
                    }
                    List<Double> list = new ArrayList<>();
                    for(int i=4;i<n+4;i++){
                        list.add(Double.parseDouble(temp[i]));
                    }
                    choose.addCourse(new Course(temp[0],temp[1],temp[2],list));
                }
                else System.out.println("wrong format");
            }
            else if(count == 5 || count == 4){//添加课程成绩信息
                if(count == 5){
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")&&temp[4].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$"))//姓名与课程名
                    {
                        for(Course c : choose.getCourses()){
                            if(c.getCourseName().equals(temp[2])){
                                choose.addScore(new Score(st,c.getWeight()));
                            }
                        }
                    }
                    else System.out.println("wrong format");
                }
                else{
                    if(temp[3].matches("^([1-9]\\d?|100|0)$")//分数
                            &&temp[0].matches("\\d{8}")//ID
                            &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$")){
                        for(Course c : choose.getCourses()){
                            if(c.getCourseName().equals(temp[2])){
                                choose.addScore(new Score(st,c.getWeight()));
                            }
                        }
                    }
                    else System.out.println("wrong format");
                }
            }
            else if(count >5){//添加实验课课程成绩
                int k = 0;
                if(temp[0].matches("\\d{8}")//ID
                        &&temp[1].matches("^[\\w\\W]{1,10}$") &&temp[2].matches("^[\\w\\W]{1,10}$")){//姓名与课程名
                    for(int i = 4; i<count;i++){
                        if(!temp[i].matches("^([1-9]\\d?|100|0)$")){
                            System.out.println("wrong format");
                            k++;
                            break;
                        }
                    }
                    if(k==0){
                        for(Course c : choose.getCourses()){
                            if(c.getCourseName().equals(temp[2])){
                                choose.addScore(new Score(st,c.getWeight()));
                            }
                        }
                    }
                }
                else System.out.println("wrong format");
            }
        }
        choose.getStuScore();
        choose.getCouScore();
        choose.getClaScore();
    }
}

class Choose {
    private ArrayList<Course> courses = new ArrayList<>();
    private ArrayList<Score> scores = new ArrayList<>();
    private ArrayList<Student> students = new ArrayList<>();
    public ArrayList<Classroom> classrooms = new ArrayList<>();
    int classnum = 0;
    public void addCourse(Course course) {//添加课程信息
        if (course.getNature().equals("必修")) {//课程性质考试形式冲突
            if (!course.getEvaluation_mode().equals("考试")) {
                System.out.println(course.getCourseName() + " : course type & access mode mismatch");
                return;
            }
        }
        if(!course.quan()){
            System.out.println(course.getCourseName()+" : number of scores does not match");
            // return;
        }
        if (!this.courses.isEmpty()) {
            int n = 0;
            for (Course c : courses) {
                if (c.getCourseName().equals(course.getCourseName())) {//课程重名
                    n++;
                }
            }
            if(n==0){
                courses.add(course);
            }
        }
        else courses.add(course);
    }
    public void addScore(Score score) {//添加课程成绩信息
        if (!this.courses.isEmpty()) {
            int n = 0;//判断课程是否存在
            for (Course c : courses) {
                if (c.getCourseName().equals(score.getCourseName())) {
                    n++;//课程存在
                    if ((c.getEvaluation_mode().equals("考试") && (score.getItemList().size()!=2)
                            ||(c.getEvaluation_mode().equals("考察")&&(score.getItemList().size()!=1)))) {
                        //成绩与考核方式不匹配
                        System.out.println(score.getStudentId() + " " + score.getStudentName() + " : access mode mismatch");
                        int xx = 0;
                        students.add(new Student(score.getStudentName(), score.getStudentId()));
                        for (Classroom cl : classrooms) {
                            if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                xx++;
                                break;
                            }
                        }
                        if (xx == 0) {//新班级
                            classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                        }
                    }
                    else {
                        scores.add(score);
                        c.addScore(score.thescore());

                        int k = 0;//判断是不是新学生
                        for (Student s : students) {
                            if (s.getID().equals(score.getStudentId())) {//之前就存在这个学生
                                k = 1;
                                s.addScores(score);
                                int yy = 0;
                                for (Classroom cl : classrooms) {
                                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                        cl.score += score.thescore();
                                        cl.k++;
                                        yy++;
                                        break;
                                    }
                                }
                            }
                        }
                        if (k == 0) {//新学生
                            int xx = 0;
                            students.add(new Student(score.getStudentName(), score.getStudentId(), score));
                            for (Classroom cl : classrooms) {
                                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                                    cl.score += score.thescore();
                                    cl.k++;
                                    xx++;
                                    break;
                                }
                            }
                            if (xx == 0) {//新班级
                                classrooms.add(new Classroom(score.thescore(), score.getStudentId().substring(0, 6)));
                                classnum++;
                            }
                        }
                    }
                }
            }
            if (n == 0) {//课程不存在
                System.out.println(score.getCourseName() + " does not exist");

                int xx = 0;
                students.add(new Student(score.getStudentName(), score.getStudentId()));
                for (Classroom cl : classrooms) {
                    if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                        xx++;
                        break;
                    }
                }
                if (xx == 0) {//新班级
                    classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
                }
            }

        }
        else{
            System.out.println(score.getCourseName() + " does not exist");

            int xx = 0;
            students.add(new Student(score.getStudentName(), score.getStudentId()));
            for (Classroom cl : classrooms) {
                if (cl.cID.equals(score.getStudentId().substring(0, 6))) {//同一班级
                    xx++;
                    break;
                }
            }
            if (xx == 0) {//新班级
                classrooms.add(new Classroom(0, score.getStudentId().substring(0, 6)));
            }
        }
    }

    public void getStuScore(){//学生所有课程总成绩平均分
        sortStu();
        for(Student s : students){
            if(s.getPjf() == 0){
                System.out.println(s.getID()+" "+s.getName() + " did not take any exams");

            }
            else {
                System.out.println(s.getID() +" "+s.getName()+ " "+s.getPjf());
            }
        }
    }

    public void getCouScore(){
        Collections.sort(courses);
        for(Course c: courses){
            if(c.getScore()==0){
                System.out.println(c.getCourseName()+" has no grades yet");
            }
            else{
                if(c.getEvaluation_mode().equals("实验")){
                    System.out.println(c.getCourseName()+" "+c.getScore()/c.getK());
                }
                else if(c.getEvaluation_mode().equals("考察")){
                    System.out.println(c.getCourseName()+" "+c.getScore()/c.getK());
                }
                else {
                    System.out.println(c.getCourseName()+" "+c.getScore()/c.getK());
                }
            }
        }
    }
    public void getClaScore(){//班级平均分
        sortCla();
        for(Classroom c:classrooms){
            c.getCScore();
        }
    }

    public void sortStu(){
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getID().compareTo(o2.getID());
            }
        });
    }

    public void sortCla(){
        Collections.sort(classrooms, new Comparator<Classroom>() {
            @Override
            public int compare(Classroom o1, Classroom o2) {
                return o1.cID.compareTo(o2.cID);
            }
        });
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }

    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }

    public ArrayList<Student> getStudents() {
        return students;
    }

    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }

}

class Course implements Comparable<Course>{
    private String courseName ;  //课程名称
    private String nature = "必修";   //课程性质
    private String access_mode = "考试";  //考核模式
    private List<Double> weight = new ArrayList<>();
    private int score = 0;
    private int k = 0;
    private int c = 0;
    //构造方法
    public Course() {

    }
    public Course(String courseName,String nature,String access_mode,List<Double> weight) {
        this.courseName = courseName;
        this.nature = nature;
        this.access_mode = access_mode;
        this.weight = weight;
        c++;
    }
    public void addScore(int s){
        score += s;
        k++;
    }
    public void addShiYanScore(int score){
        score += score;
        k++;
    }
//getset方法

    public List<Double> getWeight() {
        return weight;
    }
    public boolean quan(){
        double x=0;
        for(int i=0;i<weight.size();i++){
            x+=weight.get(i);
        }
        if(x==1){
            return true;
        }
        return false;
    }
    public void setWeight(List<Double> weight) {
        this.weight = weight;
    }

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
    public String getNature() {
        return nature;
    }
    public void setNature(String nature) {
        this.nature = nature;
    }
    public String getEvaluation_mode() {
        return access_mode;
    }
    public void setEvaluation_mode(String evaluation_mode) {
        this.access_mode = evaluation_mode;
    }

    public String getAccess_mode() {
        return access_mode;
    }

    public void setAccess_mode(String access_mode) {
        this.access_mode = access_mode;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getK() {
        return k;
    }

    public void setK(int k) {
        this.k = k;
    }

    @Override
    public int compareTo(Course o) {
        Comparator<Object> c = Collator.getInstance(Locale.CHINA);
        return ((Collator) c).compare(this.courseName,o.courseName);
    }
}
class ItemScore{//分项成绩类
    private double grade;  // 成绩分值
    private double weight;  // 成绩权重

    public double getGrade() {
        return grade;
    }

    public void setGrade(double grade) {
        this.grade = grade;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double getGradeByWeight() {  // 根据权重计算得分
        return grade * weight;
    }
}
class Score{
    private List<ItemScore> itemList = new ArrayList<>();  // 分项成绩列表
    private String studentId;
    private String studentName;
    private String courseName;
    public double getTotalGrade() {  // 计算总成绩
        double total = 0;
        for (ItemScore item : itemList) {
            total += item.getGradeByWeight();
        }
        return total;
    }
    public Score(String line,List<Double> weight) {
        String[] parts = line.split(" ");
        studentId = parts[0];
        studentName = parts[1];
        courseName = parts[2];
        if(parts.length<=5){
            int u = parts.length > 4 ? Integer.parseInt(parts[3]) : 0;
            itemList.get(0).setWeight(weight.get(0));
            itemList.get(0).setGrade(u);
            int f = Integer.parseInt(parts[parts.length - 1]);
            itemList.get(1).setWeight(weight.get(1));
            itemList.get(1).setGrade(f);
        }
        else{
            int j = 0;
            if(parts.length==weight.size()+3){
                for(int i=3;i< parts.length;i++){
                    itemList.add(new ItemScore());
                    itemList.get(j).setWeight(weight.get(j));
                    itemList.get(j).setGrade(Integer.parseInt(parts[i]));
                    j++;
                }
            } else {
                System.out.println(studentId+" "+studentName+" : access mode mismatch");
            }
        }
    }

    public int thescore(){
        return (int)getTotalGrade();
    }

    public List<ItemScore> getItemList() {
        return itemList;
    }

    public void setItemList(List<ItemScore> itemList) {
        this.itemList = itemList;
    }

    public String getStudentId() {
        return studentId;
    }
    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }
    public String getStudentName() {
        return studentName;
    }
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    public String getCourseName() {
        return courseName;
    }
    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }
}
class Student{
    private String name;
    private String ID;
    private ArrayList<Score> scores = new ArrayList<>();
    public Student(String name, String ID, Score scores) {
        this.name = name;
        this.ID = ID;
        this.scores.add(scores);
    }
    public Student(String name,String ID){
        this.name = name;
        this.ID = ID;
    }
    public void addScores(Score scores){
        this.scores.add(scores);
    }
    public int getPjf(){
        int pjf = 0;
        for(Score s : scores){
            pjf += s.thescore();
        }
        if(!scores.isEmpty())
            pjf  = pjf/ scores.size();
        return pjf;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public ArrayList<Score> getScores() {
        return scores;
    }
    public void setScores(ArrayList<Score> scores) {
        this.scores = scores;
    }
}
class Classroom{
    public int score = 0;
    public String cID;
    public int k = 0;

    public Classroom(int score, String cID) {
        this.score = score;
        this.cID = cID;
        if(score!=0){
            k++;
        }
    }

    public void getCScore(){
        if( k == 0){
            System.out.println(cID+" has no grades yet");
        }
        else{
            System.out.println(cID+" "+(int)(score/k));
        }
    }
}

 

 

三、总结反思

 本次Blog是对10-16周做的PTA题目集进行的整体概括，这段时间题目的难度比较大，没有哪一次题目是临时可以轻轻松松通过的，都需要花费大量时间琢磨、修改。在这一阶段，我的编程能力得到了一定的提升。尤其是多次迭代程序，也是让我认识到规划好程序设计有多么重要。在完成程序编写后，需要进行测试和评估，以确认程序是否满足要求，需要正确处理各种错误和异常情况。在进行测试时，需要尽可能地覆盖各种可能的输入数据和情况，以确保程序的正确性。此外还要考虑程序的性能和复杂，需要根据实际情况来评估程序的运行效率和内存消耗情况。如统计java关键字那次作业，就让我深刻认识到写出代码不是什么难事，我们需要不断打磨，使代码更加高效、更加简洁

，一次次的迭代也让我明白“可拓展性”这四个字有多么重要。

 

 

四、课程建议与看法

1、本门课程的教学方法采用边讲边练的教学方式，老师在讲授知识的同时，也会辅以实例演示和练习，以帮助学生更好地掌握并运用所学知识。

2、本门课程采用线上线下混合式教学，能够同时兼顾线上、线下两方面的教学方式。但针对混合式教学，应当更加注重线上部分的教学质量和实时性。如果大家课前学习通视频观看完成率、线上交互较少，会影响学生的学习效果和体验，线上学习不到位会导致线下学习效率低，进而恶性循环。

3、本门课程采用PTA题目集驱动的教学过程，但是我们老师没有给我们讲解PTA题目或是对每次的题目编程情况进行知道，有可能导致学生不断犯错。在学生提交题目后，教师可以针对问题进行详讲和解答。