第三次pta作业总结

一.前言

第七次题目集：

　　　　　　这次题目集只有一道题，是菜单计价系统的最后的一次迭代，也就是第五次迭代，相最原始的菜单计价系统，这次的题目新加入了特色菜，分为川菜、晋菜和浙菜，新加入了对手机号码的约束，新加入了营业时间，还有一些异常处理，一对比发现还是增加挺多内容的。

第八次题目集：

　　　　　　这次的题目集有了新的题目，而不是菜单计价系统的新的迭代，这次是课程成绩统计系统。要求输入学生和考试成绩等一些有关的信息，然后输出对应的成绩。而考试有对应的种类，分别为考察和考试，也有两种不同的性质，分别为必修和选修。这样本就可以组合成四种不同的情况，但是有了约束：必修必须对应考试，所以组合的情况就由原本的四次变成了现在的三次。除此之外，还有一些相关约束：成绩不能小于0也不能大于100，学号只能由8位数字组成，姓名不超过10个字符，课程名称不能超过10个字符。

第九次题目集：

　　　　　　统计Java程序中关键词的出现次数，这次的题目和之前的有些不太一样，我认为这次的题目主要是最数据进行清理，重中之重也是数据清洗这一部分，之后再用正则表达式去匹配数据并且统计各个关键词出现的次数，还有一小点要注意的就是要对一些特殊字符进行处理，比如像：，.？！这种，还有要去掉多余的空格，不然获得的单词也会和想要获取的单词之间由差错。

第十次题目集：

　　　　　　第一题： 容器-HashMap-检索。这道题主要是利用map来储存数据，map作为容器是比较特殊的，特殊在他储存的是键值对，key和value。key和value之间有一个映射关系，同时这些键值对也没有对应的索引，所以不能像Array或者ArrayList一样通过索引来实现遍历，只能通过迭代器iterater或者通过增强for来遍历map的key对应的set。只要弄懂了这些map的基本原理，这道题目就不算难。

　　　　　　第二题：容器-HashMap-排序。相比于第一道题，这道题只是增加了对HashMap的排序，和刚才说的一样，map中储存的是键值对，HashMap也是一样。我们要对map进行排序的话，只能选择对key进行排序还是对value进行排序，选取后再获取对应的key的set，即key_set或则和是value_set。然后再对key_set或者value_set进行排序，排序后再遍历对应的set来获取map的值，也就是说对map的排序其实就是对set的排序，而set可以通过toArray（）转化成Array，Array又有一个static方法sort可以对数组进行排序。

　　　　　　第三题：课程成绩统计程序-2。是对课程成绩统计程序的第二次迭代，和之前差不多，就不再细说了。

　　　　　　第四题：动物发声模拟器（多态）。正如题目所说的，这道题主要考察的是多态的知识点，多态作为类与对象的三大特性之一，自然有着很广泛的应用和较高的应用频率。多态的使用约束我认为有两点：首先要有两个类，并且这两个类之间要有继承关系，第二要让父类对象指向子类对象，也就是要用父类的类型去接收子类的对象。多态正如他的名字一样，我个人对多态的理解是：一段相同的代码，对于传入不同的数据，他能够体现不同的形态。就好比用Animal去接收Cat和Dog，调用Animal的eat（），此时会根据传入的是cat或者是dog来返回不同的结果，这样可以使原本大量的代码变得更加简洁。那是不是使用多态就一定好呢？我不这样认为，多态也有他的缺点，当我们用父类指向子类的时候，我们可以调用的方法可能会减少，有一句有关多态的话：编译看左边，执行看右边。也就是说当我们使用多态的时候，只有父类有的方法我们才能使用，有时我们的子类相比于父类新加入了一些方法，但此时我们却不可以使用这些新加入的方法。

第十一次题目集：

　　　　　　第一题：容器-ArrayList-排序。正如题目的名字一样，对ArrayList进行排序，只要ArrayList的sort方法，再根据需要重写一个比较器即可。ArrayList作为数组的“升级版”，数组能做的他都能做，数组不能做的他也能做，我在最开始接触ArrayList的时候认为有了这种好东西谁还用数组？为什么不把数组删掉只保留ArrayList？到了现在，我又有了新的看法：数组对比于ArrayList，最大的特点就是不能扩容，很多时候不能扩容使一种麻烦，但我也认为这使一种约束，约束我们不去更改他的容量，虽然从特性上使可以更改数组内的数据的，但我觉得我们不应该去轻易修改数组的数据，当我们有要经常修改的数据时就用ArrayList。那既不修改又不扩容，我们在什么时候使用数组呢？打个比方，当我们要做一些日期题目的时候，我们可以用数组去保存12个月所对应的天数，当我们使用dfs和bfs时，我们会使用next数组来对应四种可能发生的情况。

　　　　　　第二题：课程成绩统计程序-3。课程成绩统计程序的第三次迭代，不细说。

　　　　　　第三题：jmu-Java-02基本语法-03-身份证排序。和第一题一样，用ArrayList储存数据再进行排序。

　　　　　　第四题：jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack。这道题是对栈Stack的实现，大部分都没有什么说的，但有一点需要注意的地方：当我们pop（）数据的时候不用真的把数据从数组中移出，我们只需要让对应的指针更改位置，同时让size减1即可，这道题不需要使用指针。

　　　　　　第五题：jmu-Java-03面向对象基础-05-覆盖。这道题是让我们按照要求写一个类，主要在于equals（）和toString（）的重写。首先就有一个问题了：我都没让写的这个类去继承其他的类，为什么还可以重写这两个方法？这就不得不提到所有类的爹——Object了，object有两个方法，就是equals（）和toString（），而所有的类都继承Object。是的没错，就算你没写你的类也会自动继承Object，并且你不想继承还不行，必须得继承，也就是说所有的类都可以重写这两个方法，所以说掌握了这两个方法如何进行重写对我们的帮助很大。

 

7.1：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        boolean is_in_table=false;
        Menu menu=new Menu();
        Order order=null;
        ArrayList<Order> orders=new ArrayList<Order>();



        while(true){
            String line=sc.nextLine();
            if(line.equals("end")) {
               if(order!=null) orders.add(order);


                break;
            }

            String[] data = line.split(" ");

            if(data.length==2){
                if(!is_in_table){
//                    System.out.println("添加了一份普通菜到菜单！");
                    String dish_name=data[0];
                    int unit_price=0;
                    if(is_number(data[1])){
                        unit_price=Integer.parseInt(data[1]);
                        menu.dishes.put(dish_name,unit_price);
                    }else{
//                        System.out.println("添加普通菜到菜单的输入的2不是数字！");
                        System.out.println("wrong format");
                    }
                }else{
//                    System.out.println("删除一份菜！");
                    if(is_number(data[0])){
                        order.del_a_Record_by_order(Integer.parseInt(data[0]));
                    }else{
                        System.out.println("delete error");
                    }
                }
            }else if (data.length==4){
                if(!is_in_table){
//                    System.out.println("添加了一份特色菜到菜单！");
                    String dish_name=data[0];
                    String type=data[1];
                    int unit_price=Integer.parseInt(data[2]);

                    menu.add_dish(dish_name,unit_price);
                    menu.add_dish_types(dish_name,type);
                }else{
//                    System.out.println("点了一份普通菜！");
                    int record_id=Integer.parseInt(data[0]);
                    String dish_name=data[1];
                    int size=Integer.parseInt(data[2]);
                    int num=Integer.parseInt(data[3]);

                    Record record = new Record(record_id, dish_name, size, num, menu);
                    if(!record.check_dish_isExist(dish_name,menu)){
                        System.out.println(dish_name+" does not exist");
                        continue;
                    }
                    if(order==null) continue;
                    order.add_record(record);

                    record.show();
                }

            }else if(data.length==7){
//                System.out.println("------桌号-------");
                is_in_table=true;

                int order_id=Integer.parseInt(data[1]);
                String name=data[3];
                String tel=data[4];
                String date=data[5];
                String time=data[6];

                if (order != null) {
                    orders.add(order);
                }
                order=new Order(name,tel,date,time,order_id);
                if(!order.check_name(name)||!order.check_tel(tel)){
                    System.out.println("wrong format");
                    order=null;
                    continue;
                }
                if(!order.check_date(date,time)){
                    System.out.println("table "+order_id+" out of opening hours");
                    order=null;
                    continue;
                }

                System.out.println("table "+data[1]+": ");
            }else if(data.length==5){
                if(is_number(data[1])){
//                    System.out.println("代点了一份普通菜！");
                    int order_id=Integer.parseInt(data[0]);
                    int record_id=Integer.parseInt(data[1]);
                    String dish_name=data[2];
                    int size=Integer.parseInt(data[3]);
                    int num=Integer.parseInt(data[4]);

                    for (Order o:orders){
                        if(o.getOrder_id()==order_id){
                            Record record = new Record(record_id, dish_name, size, num, menu);
                            o.add_record(record);
                            record.show();
                            break;
                        }
                    }
                }else{
//                    System.out.println("点了一份特色菜!");
                    int record_id=Integer.parseInt(data[0]);
                    String dish_name=data[1];
                    int level=Integer.parseInt(data[2]);
                    int size=Integer.parseInt(data[3]);
                    int num=Integer.parseInt(data[4]);
                    String dish_type=menu.search_type(dish_name);
                    if(dish_type==null){
                        continue;
                    }
                    if(dish_type.equals("川菜")){
                        if(level<0||level>5){
                            System.out.println("spicy num out of range :"+level);
                            continue;
                        }
                    }else if(dish_type.equals("晋菜")){
                        if(level<0||level>4){
                            System.out.println("acidity num out of range :"+level);
                            continue;
                        }
                    }else if(dish_type.equals("浙菜")){
                        if(level<0||level>3){
                            System.out.println("sweetness num out of range :"+level);
                            continue;
                        }
                    }
                    Record record = new Record(record_id, dish_name, size, num, menu);
                    if(order==null) continue;
                    order.add_record(record);


                    order.update(dish_type,level,num);
                    record.show();
                }
            }else if(data.length==6){
//                System.out.println("代点一份特色菜！");
                int order_id=Integer.parseInt(data[0]);
                int record_id=Integer.parseInt(data[1]);
                String dish_name=data[2];
                int level=Integer.parseInt(data[3]);
                int size=Integer.parseInt(data[4]);
                int num=Integer.parseInt(data[5]);
                String dish_type=menu.search_type(dish_name);

                for (Order o:orders){
                    if(o.getOrder_id()==order_id){
                        Record record = new Record(record_id, dish_name, size, num, menu);
                        o.add_record(record);
                        o.update(dish_type,level,num);
                        int price_old = record.get_price();
                        int price_new = record.get_new_price_special(o.getDate(), o.getTime());
                        int price_new_new = record.get_new_price_special(order.getDate(), order.getTime());


                        System.out.println(record.getRecord_id()+" table "+order.getOrder_id()+" pay for table "+o.getOrder_id()+" "+price_old);
                        order.my_sum_old+=price_old;
                        order.my_sum+=price_new_new;
                        o.my_sum-=price_new;
                        o.my_sum_old-=price_old;
                    }
                }
            }else{
                System.out.println("wrong format");
            }
        }
//        System.out.println("-------------------");
        if(order==null) return ;
        for(Order o:orders){
            o.show(menu);
//            System.out.println(o.getDate()+" "+o.getTime());
        }
        orders.sort(new Comparator<Order>() {
            @Override
            public int compare(Order o1, Order o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
//        HashMap<String,Integer> information=new HashMap<String,Integer>();
        ArrayList<String> name_and_tels=new ArrayList<String>();
        ArrayList<Integer> prices=new ArrayList<Integer>();

        int sum=0;
        String name_and_tel_pre="";
        String name_and_tel_now="";
       for(int i=0;i<orders.size();i++){
           Order o=orders.get(i);
            if(i==0){
                sum+=o.get_total_price_new(menu);
                name_and_tel_pre=o.getName()+" "+o.getTel();
                 name_and_tel_now=o.getName()+" "+o.getTel();
            }else{
                name_and_tel_now=o.getName()+" "+o.getTel();
                if(!name_and_tel_now.equals(name_and_tel_pre)){
                    name_and_tels.add(name_and_tel_pre);
                    prices.add(sum);
                    sum=0;
                }
                sum+=o.get_total_price_new(menu);
                name_and_tel_pre=name_and_tel_now;
            }
       }
       name_and_tels.add(name_and_tel_now);
       prices.add(sum);
       for(int i=0;i<name_and_tels.size();i++){
           System.out.println(name_and_tels.get(i)+" "+prices.get(i));
       }
//       for(String key:information.keySet()){
//           System.out.println(key+" "+information.get(key));
//       }

    }
    public static boolean is_number(String str) {
        return str.matches("^[0-9]*$");
    }
    public static class Dish {
    private String name;
    private int unit_price;

    public int getPrice(int size){
        if(size==1) return this.unit_price;
        if (size==2) return (int)(this.unit_price*1.5+0.5);
        if (size==3) return this.unit_price*2;
//        System.out.println("Dish.getPrice() input wrong!");
        System.out.println("wrong format");
        return -1;
    }



    public Dish() {
    }

    public Dish(String name, int unit_price) {
        this.name = name;
        this.unit_price = unit_price;
    }

    public Dish(String name,Menu m){
        this.name=name;
        this.unit_price=m.dishes.get(name);
    }

    public String getName() {
        return name;
    }

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

    public int getUnit_price() {
        return unit_price;
    }

    public void setUnit_price(int unit_price) {
        this.unit_price = unit_price;
    }

}

public static class Menu {
        HashMap<String,Integer> dishes=new HashMap<String,Integer>();
        HashMap<String,String> dish_types=new HashMap<String,String>();

    public Dish search_dish(String dish_name){
            Dish dish=null;
            try{
                dish= new Dish(dish_name,dishes.get(dish_name));
            }catch (Exception e){
//                System.out.println("Menu中的搜索方法传入的菜品名称不存在！！！");
                System.out.println(dish_name+" does not exist");
            }
            return dish;
        }

        public void add_dish(String dish_name,int unit_price){
            dishes.put(dish_name,unit_price);
        }
        public void add_dish_types(String dish_name,String type){
            dish_types.put(dish_name,type);
        }
        public String search_type(String dish_name){
            return dish_types.get(dish_name);
        }
/*
    public static void main(String[] args) {
        Menu menu = new Menu();
        menu.add_dish("麻婆豆腐",20);
        menu.add_dish("麻婆豆腐",30);
        System.out.println(menu.search_dish("麻婆豆腐").getPrice(1));
    }
 */
/*
    public static void main(String[] args) {
        System.out.println(is_number("10"));
}

    public static boolean is_number(String str) {
        return str.matches("^[0-9]*$");
    }
 */

}

public static class Order {
    public int my_sum=0;
    public int my_sum_old=0;
    ArrayList<Record> records=new ArrayList<Record>();

    static String []hot={
            "不辣",
            "微辣",
            "稍辣",
            "辣",
            "很辣",
            "爆辣"
    };
    static String []sour={
            "不酸",
            "微酸",
            "稍酸",
            "酸",
            "很酸"
    };
    static String []sweet={
            "不甜",
            "微甜",
            "稍甜",
            "甜"
    };

    private String name;
    private String tel;
    private String date;
    private String time;
    private int order_id;

    public int hot_sum=0;
    public int hot_count=0;
    public int sour_sum=0;
    public int sour_count=0;
    public int sweet_sum=0;
    public int sweet_count=0;

    public void update(String dish_type,int level,int num){

        if(dish_type.equals("川菜")){
            this.setHot_sum(this.getHot_sum()+level*num);
            this.setHot_count(this.getHot_count()+num);
        }else if(dish_type.equals("晋菜")){
            this.setSour_sum(this.getSour_sum()+level*num);
            this.setSour_count(this.getSour_count()+num);
        }else if(dish_type.equals("浙菜")){
            this.setSweet_sum(this.getSweet_sum()+level*num);
            this.setSweet_count(this.getSweet_count()+num);
        }else{
//            System.out.println("点的不是特色菜！");
            System.out.println("wrong format");
        }
    }

    public int getHot_sum() {
        return hot_sum;
    }

    public void setHot_sum(int hot_sum) {
        this.hot_sum = hot_sum;
    }

    public int getHot_count() {
        return hot_count;
    }

    public void setHot_count(int hot_count) {
        this.hot_count = hot_count;
    }

    public int getSour_sum() {
        return sour_sum;
    }

    public void setSour_sum(int sour_sum) {
        this.sour_sum = sour_sum;
    }

    public int getSour_count() {
        return sour_count;
    }

    public void setSour_count(int sour_count) {
        this.sour_count = sour_count;
    }

    public int getSweet_sum() {
        return sweet_sum;
    }

    public void setSweet_sum(int sweet_sum) {
        this.sweet_sum = sweet_sum;
    }

    public int getSweet_count() {
        return sweet_count;
    }

    public void setSweet_count(int sweet_count) {
        this.sweet_count = sweet_count;
    }

    public Order() {
    }

    public Order(String name, String tel, String date, String time, int order_id) {
        this.name = name;
        this.tel = tel;
        this.date = date;
        this.time = time;
        this.order_id = order_id;
    }

    public String getName() {
        return name;
    }

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

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public int getOrder_id() {
        return order_id;
    }

    public void setOrder_id(int order_id) {
        this.order_id = order_id;
    }

    public int get_total_price(){
        int sum=0;
        for(Record r:records){
            sum+=r.get_price();
        }
        return sum+my_sum_old;
    }
    public int get_total_price_new(Menu menu){
        int sum=0;
        for(Record r:records){
            if(r.isSpecial(menu)){
                sum+=r.get_new_price_special(this.date,this.time);
            }else{
                sum+=r.get_new_price(this.date,this.time);
            }
        }
//        System.out.println("my_sum="+my_sum);
        return sum+my_sum;
    }
    public Record add_record(int order_id,String dish_name,int size,int num,Menu menu){
        Record record = new Record(order_id, new Dish(dish_name, menu), size, num);
        records.add(record);
        return record;
    }
    public Record add_record(Record record){
        records.add(record);
        return record;
    }
    public Record del_a_Record_by_order(int order_id){
        for(Record r:records){
            if(r.getRecord_id()==order_id){
                records.remove(r);
                return r;
            }
        }
        System.out.println("delete error");
        return null;
    }
    public Record find_Record_by_id(int order_id){
        for (Record r:records){
            if(r.getRecord_id()==order_id) return r;
        }
//        System.out.println("Order.查找方法输入的order_id不存在！！！");
        System.out.println("wrong format");
        return null;
    }
    public void show(Menu menu){
        int price_old=this.get_total_price();
        int price_new=this.get_total_price_new(menu);

        System.out.print("table "+order_id+": "+price_old+" "+price_new);
        if(this.hot_count!=0) {
            int level=(int)(this.hot_sum/(double)this.hot_count+0.5);
            String s_level=hot[level];
            System.out.print(" 川菜"+" "+this.hot_count+" "+s_level);
        }
        if(this.sour_count!=0) {
            int level=(int)(this.sour_sum/(double)this.sour_count+0.5);
            String s_level=sour[level];
            System.out.print(" 晋菜"+" "+this.sour_count+" "+s_level);
        }
        if (this.sweet_count!=0) {
            int level=(int)(this.sweet_sum/(double)this.sweet_count+0.5);
            String s_level=sweet[level];
            System.out.print(" 浙菜"+" "+this.sweet_count+" "+s_level);
        }
        System.out.println();
    }
     public boolean check_tel(String tel){
        String regex="^(180|181|189|133|135|136)[0-9]{8}$";
        return tel.matches(regex);
     }
     public boolean check_name(String name){
        return name.length()<=10;
     }
     public boolean check_date(String date,String time){
         int week = Record.getWeek(date);

         int h=Integer.parseInt(time.substring(0,2));
         int m=Integer.parseInt(time.substring(3,5));
         int s=Integer.parseInt(time.substring(6,8));

         if(1<=week&&5>=week){
             if((h>=17&&h<20)||(h==20&&m<=30)){
                return true;
             }else if((h>=11&&h<14)||(h==10&&m>=30)||(h==14&&m<=30)){
                return true;
             }else {
                return false;
             }
         }else{
             if((h>9&&h<21)||(h==9&&m>=30)||(h==21&&m<=30)){
                return true;
             }
             else {
                return false;
             }
         }
     }
/*
    public static void main(String[] args) {
//        Order order = new Order("Alen","18007969174","2023/5/6","21/10/13",1);
        System.out.println(check_tel("18207969174"));
    }

 */

}

public static class Record {
    private int record_id;
    private Dish d;
    private int size;
    private int num;

    public boolean isSpecial(Menu menu){
        return menu.dish_types.containsKey(this.d.getName());
    }

    public int get_price(){
        return this.d.getPrice(this.size)*this.num;
    }
    public int get_new_price(String date,String time){
        int price = this.get_price();
        int week=getWeek(date);
        int h=Integer.parseInt(time.substring(0,2));
        int m=Integer.parseInt(time.substring(3,5));
        int s=Integer.parseInt(time.substring(6,8));
        if(1<=week&&5>=week){
            if((h>=17&&h<20)||(h==20&&m<=30)){
                return (int)(price*0.8+0.5);
            }else if((h>=11&&h<14)||(h==10&&m>=30)||(h==14&&m<=30)){
                return (int)(price*0.6+0.5);
            }else {
//                System.out.println("不在营业时间内！");
                System.out.println("wrong format");
            }
        }else{
            if((h>9&&h<21)||(h==9&&m>=30)||(h==21&&m<=30)) return price;
            else {
//                System.out.println("不在营业时间内！");
                System.out.println("wrong format");
            }
        }
        return -1;
    }
    public int get_new_price_special(String date,String time){
        int price = this.get_price();
        int week=getWeek(date);
        if(1<=week&&5>=week) price=(int)(price*0.7+0.5);
        return price;
    }
public static int getWeek(String date)  {
    // 再转换为时间
    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
    String[] weeks = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
    Date parseDate = null;
    try {
        parseDate = dateFormat.parse(date);
    } catch (ParseException e) {
//        System.out.println("输入的日期不对！");
        System.out.println("wrong format");
        return -1;
    }
    Calendar c = Calendar.getInstance();
    c.setTime(parseDate);
    int week_index = c.get(Calendar.DAY_OF_WEEK) - 1;
    if (week_index < 0) {
        week_index = 0;
    }
    return week_index;
}

    public Record() {
    }

    public Record(int record_id, Dish d, int size, int num) {
        this.record_id = record_id;
        this.d = d;
        this.size = size;
        this.num = num;
    }
    public Record(int record_id,String dish_name,int size,int num,Menu menu){
        this.record_id = record_id;
        this.d = new Dish(dish_name,menu);
        this.size = size;
        this.num = num;
    }

    public int getRecord_id() {
        return record_id;
    }

    public void setRecord_id(int record_id) {
        this.record_id = record_id;
    }

    public Dish getD() {
        return d;
    }

    public void setD(Dish d) {
        this.d = d;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
    public void show(){
        System.out.println(this.record_id+" "+this.d.getName()+" "+this.get_price());
    }
    public boolean check_dish_isExist(String dish_name,Menu menu){
        return menu.dishes.containsKey(dish_name);
    }
/*
    public static void main(String[] args) {
        Record record = new Record(1, new Dish("麻婆豆腐", 20), 3, 5);
        System.out.println(record.get_price());
    }
 */

}


}

8.1

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);

        Students    students = new Students();
        Courses courses = new Courses();
        Classes classes = new Classes();

        while(true){
            String line = sc.nextLine();
            if(line.equals("end")) break;

            String[] data =line.split(" ");

            if(data.length==2){
//                System.out.println("----------输入了课程信息(一定是必修)------------");
                String name=data[0];
                String type=data[1];
                
                if(type.equals("考察")){
                    System.out.println("wrong format");
                    continue;
                }
               if(courses.find_course(name)!=null){
                    continue;
                }
                courses.add_course(new Course("考试",type,name));
            }else if(data.length==3){
//                System.out.println("----------输入了课程信息------------");
                String name=data[0];
                String type=data[1];
                String assess=data[2];

                if(type.equals("必修")&&assess.equals("考察")){
                    System.out.println(name+" : course type & access mode mismatch");
                    continue;
                }
                if(courses.find_course(name)!=null){
                    continue;
                }
                courses.add_course(new Course(assess,type,name));

            }else if(data.length==4){
//                System.out.println("----------输入了学生信息和分数信息（一定是考察成绩）------------");
                int sid=Integer.parseInt(data[0]);
                String name_student=data[1];
                String name_course=data[2];
                int score_fin=Integer.parseInt(data[3]);
                int cid=sid/100;

                if(score_fin<0||score_fin>100){
                    System.out.println("wrong format");
                    continue;
                }

                Student student;
                Score score = new Score(score_fin);
                Course course = courses.find_course(name_course);

                Class c;
                if(classes.if_exist_class(cid)) {
                    c = classes.find_class(cid);
                }else{
                    c=new Class(cid);
                }

                if(students.if_exist_student(sid)){
                    student=students.find_student(sid);
                }else{
                    student=new Student(sid,cid,name_student);
                }
                if(course==null){
                    System.out.println(name_course+" does not exist");
                    if(!students.if_exist_student(sid)) students.add_student(student);
                    if(!classes.if_exist_class(cid)) classes.add_class(c);
                    continue;
                }

                Agent agent = new Agent(course, student, score,c);

//                System.out.println(cid+"班级开始更新数据........");
                if(!course.getType().equals("选修")){
                    System.out.println(student.getSid()+" "+student.getName()+" : "+"access mode mismatch");
                }else{
                    agent.update_ignore_ord_score();
                }
//                agent.update_ignore_ord_score();

                if(!students.if_exist_student(sid)) students.add_student(student);
                if(!classes.if_exist_class(cid)) classes.add_class(c);

            }else if(data.length==5){
//                System.out.println("----------输入了学生信息和分数信息（一定是考试成绩）------------");
                int sid=Integer.parseInt(data[0]);
                String name_student=data[1];
                String name_course=data[2];
                int score_ord=Integer.parseInt(data[3]);
                int score_fin=Integer.parseInt(data[4]);
                int cid=sid/100;

                if((score_fin<0||score_fin>100)||(score_ord<0||score_ord>100)){
                    System.out.println("wrong format");
                    continue;
                }

                Student student ;
                Score score = new Score(score_ord,score_fin);
                Course course = courses.find_course(name_course);

                Class c;
                if(classes.if_exist_class(cid)) {
                    c = classes.find_class(cid);
                }else{
                    c=new Class(cid);
                }

                if(students.if_exist_student(sid)){
                    student=students.find_student(sid);
                }else{
                    student=new Student(sid,cid,name_student);
                }

                if(course==null){
                    System.out.println(name_course+" does not exist");
                    if(!students.if_exist_student(sid)) students.add_student(student);
                    if(!classes.if_exist_class(cid)) classes.add_class(c);
                    continue;
                }

                //  if(!course.getAssess().equals("考试")){
                //     System.out.println("wrong format");
                //     continue;
                // }

                Agent agent = new Agent(course, student, score,c);

                    agent.update();


                if(!students.if_exist_student(sid)) students.add_student(student);
                if(!classes.if_exist_class(cid)) classes.add_class(c);
            }
        }

        students.sort();
        courses.sort();
        classes.sort();


        students.show();
        courses.show();
        classes.show();
    }
    public static class Agent {
    private Course course;
    private Student student;
    private Score score;
    private Class c;

    public void update_ignore_ord_score() {
        int grade_ignore_ord_score = this.score.get_grade_ignore_ord_score();
        student.add_grade(grade_ignore_ord_score);
        course.add_grade(score);
        c.add_student(student);
    }
    public void update(){
        double grade=score.get_grade();
        student.add_grade(grade);
        course.add_grade(score);
        c.add_student(student);
    }

    public Agent() {
    }

    public Agent(Course course, Student student, Score score,Class c) {
        this.course = course;
        this.student = student;
        this.score = score;
        this.c=c;
    }

    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public Score getScore() {
        return score;
    }

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

    public Class getC() {
        return c;
    }

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

public static class Class {
    private int cid;
    private ArrayList<Student> students = new ArrayList<Student>();

    public int get_avg_score(){
        if(this.students.size()==0) return 0;
        double sum = 0;
        for(Student student : students){
            sum+=student.get_avg_sum_grade();
        }
        return (int)((sum+0.5)/students.size());
    }

    public void show(){
        if(students.size()==0){
            System.out.println(this.cid+" has no grades yet");
            return ;
        }
        System.out.println(this.getCid()+" "+this.get_avg_score());
    }
    public void add_student(Student student){
        this.students.add(student);
    }

    public Class() {
    }

    public Class(int cid) {
        this.cid = cid;
    }

    public int getCid() {
        return cid;
    }

    public void setCid(int cid) {
        this.cid = cid;
    }

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

public static class Classes {
    private ArrayList<Class> classes = new ArrayList<Class>();

    public Class find_class(int cid){
       for(Class c : classes){
           if(c.getCid()==cid) return c;
       }
       return null;
    }
    public void add_class(Class c){
        this.classes.add(c);
    }
    public boolean if_exist_class(int cid){
        for(Class c : classes){
            if(c.getCid()==cid) return true;
        }
        return false;
    }

    public void sort(){
        this.classes.sort(new Comparator<Class>() {
            @Override
            public int compare(Class o1, Class o2) {
                if(o1.getCid()<o2.getCid()) return -1;
                if(o1.getCid()>o2.getCid()) return 1;
                return 0;
            }
        });
    }
    public void show(){
        for(Class c : classes){
            c.show();
        }
    }

    public Classes() {
    }

    public ArrayList<Class> getClasses() {
        return classes;
    }
}

public static class Course {
    private String assess;//考核种类，0代表考试，1代表考察
    private String type;//0代表必修，1代表选修;
    String name;
    private ArrayList<Score> scores = new ArrayList<Score>();

    public int get_avg_grade_org(){
        double sum=0;
        int count=0;
        for(Score score : scores) {
            if(score.getScore_ord()==0){
                count++;
            }
            sum += score.getScore_ord();
        }
        if(scores.size()-count==0) return 0;
        return (int)((sum)/(scores.size()-count));
    }
    public int get_avg_grade_fin(){
        double sum=0;
        for(Score score : scores) {
            sum+=score.getScore_final();
        }
        return (int)((sum)/scores.size());
    }

    public int get_avg_grade(){
        double sum=0;
        if(this.get_avg_grade_org()!=0){
            for(Score score : scores) {
                sum+=score.get_grade();
            }
        }else{
            for(Score score : scores) {
                sum+=score.get_grade_ignore_ord_score();
            }
        }

        return (int)((sum)/scores.size());
    }
    public void add_grade(Score score){
        this.scores.add(score);
    }
    public void show(){
        if(this.scores.size()==0){
            System.out.println(this.getName()+" "+"has no grades yet");
            return ;
        }
        if(this.get_avg_grade_org()!=0){
            System.out.println(this.getName()+" "+this.get_avg_grade_org()+" "+this.get_avg_grade_fin()+" "+this.get_avg_grade());
        }
        else System.out.println(this.getName()+" "+this.get_avg_grade_fin()+" "+this.get_avg_grade());
    }

    public Course() {
    }

    public Course(String assess, String type,String name) {
        this.assess = assess;
        this.type = type;
        this.name=name;
    }

    public String getAssess() {
        return assess;
    }

    public void setAssess(String assess) {
        this.assess = assess;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

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

    public String getName() {
        return name;
    }

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

public static class Courses {
    private ArrayList<Course> courses = new ArrayList<Course>();

   public void add_course(Course course) {
       this.courses.add(course);
   }
   public Course find_course(String name){
       for(Course course : courses){
           if(course.getName().equals(name)) return course;
       }
       return null;
   }
   public void sort(){
       courses.sort(new Comparator<Course>() {
           @Override
           public int compare(Course o1, Course o2) {
               if(o1.getName().charAt(0)>'z'&&o2.getName().charAt(0)>'z'){
                   if(o1.getName().compareTo(o2.getName())>0) return -1;
                   if(o1.getName().compareTo(o2.getName())<0) return 1;
               }else{
                   if(o1.getName().compareTo(o2.getName())>0) return 1;
                   if(o1.getName().compareTo(o2.getName())<0) return -1;
               }
               return 0;
           }
       });
   }

   public void show(){
       for(Course course:courses){
           course.show();
       }
   }

    public Courses() {
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }
}
public static class Score {
    private double weighting_ord=0.3;
    private double weighting_final=0.7;
    private int score_ord=0;
    private int score_final;


    public double get_grade(){
        return weighting_ord*score_ord+weighting_final*score_final;
    }
    public int get_grade_ignore_ord_score(){
        return this.score_final;
    }

    public Score() {
    }

    public Score(int score_final) {
        this.score_final = score_final;
    }

    public Score(int score_ord, int score_final) {
        this.score_ord = score_ord;
        this.score_final = score_final;
    }


    public double getWeighting_ord() {
        return weighting_ord;
    }

    public void setWeighting_ord(double weighting_ord) {
        this.weighting_ord = weighting_ord;
    }

    public double getWeighting_final() {
        return weighting_final;
    }

    public void setWeighting_final(double weighting_final) {
        this.weighting_final = weighting_final;
    }

    public int getScore_ord() {
        return score_ord;
    }

    public void setScore_ord(int score_ord) {
        this.score_ord = score_ord;
    }

    public int getScore_final() {
        return score_final;
    }

    public void setScore_final(int score_final) {
        this.score_final = score_final;
    }
}


public static class Student {
    private int sid;
    private int cid;
    private String name;
    private ArrayList<Double> scores = new ArrayList<Double>();

    public int get_avg_sum_grade(){
        int sum=0;
        for(double score:scores)  sum+=score;
//        System.out.println("sum = "+sum+" size = "+scores.size());
        return (int)((sum+=0.5)/scores.size());
    }
    public void add_grade(double score){
        this.scores.add(score);
    }

    public void show(){
        if(this.scores.size()==0){
            System.out.println(this.sid+" "+this.name+" "+"did not take any exams");
            return ;
        }
        System.out.println(this.getSid()+" "+this.getName()+ " "+this.get_avg_sum_grade());
    }

    public Student() {
    }
    public Student(int sid,String name){
        this.sid=sid;
        this.cid=sid/100;
        this.name=name;
    }
    public Student(int sid, int cid,String name) {
        this.sid = sid;
        this.cid = cid;
        this.name=name;
    }

    public int getSid() {
        return sid;
    }

  public void setSid(int sid) {
        this.sid = sid;
    }

    public int getCid() {
        return cid;
    }

    public void setCid(int cid) {
        this.cid = cid;
    }

    public String getName() {
        return name;
    }

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

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

public static class Students {
    private ArrayList<Student> students = new ArrayList<Student>();


    public Student find_student(int sid){
        for(Student student : students){
            if(student.getSid()==sid) return student;
        }
        return null;
    }
    public void add_student(Student student){
        this.students.add(student);
    }
    public boolean if_exist_student(int sid){
        for(Student student : students){
            if(student.getSid()==sid) return true;
        }
        return false;
    }

    public void sort(){
        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getSid()<o2.getSid()) return -1;
                if(o1.getSid()>o2.getSid()) return 1;
                return 0;
            }
        });
    }

    public void show(){
        for(Student student : students){
            student.show();
        }
    }

    public Students() {
    }

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

}

9.1

import java.util.*;

public class Main {
    public static void main(String[] args) {
        StringBuilder data = new StringBuilder();

        String[] keyWord = {"abstract", "assert", "boolean",
                "break", "byte", "case", "catch", "char", "class",
                "const", "continue", "default", "do", "double", "else",
                "enum", "extends", "false", "final", "finally", "float", "for",
                "goto", "if", "implements", "import", "instanceof", "int", "interface",
                "long", "native", "new", "null", "package", "private", "protected", "public",
                "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this",
                "throw", "throws", "transient", "true", "try", "void", "volatile", "while"};

        Scanner sc = new Scanner(System.in);

        while (true) {
            String line = sc.nextLine();
            if (line.equals("exit")) break;

            if (line.matches(".*//.*")) {
                String[] s = line.split("//");
                data.append(s[0]).append(" ");
            } else {
                data.append(line).append(" ");
            }
        }
        String str = data.toString();
        
      if(str.isEmpty()) {
            System.out.println("Wrong Format");
            return ;
        }
        
        String data_str = str.replaceAll("/\\*.*?\\*/", "");
        data_str = data_str.replaceAll("\".*?\"","");

        data_str =  data_str.replaceAll("\\("," ");
        data_str =  data_str.replaceAll("\\)"," ");
        data_str =  data_str.replaceAll("\\["," ");
        data_str =  data_str.replaceAll("]"," ");
        data_str =  data_str.replaceAll("\\{"," ");
        data_str =  data_str.replaceAll("}"," ");
        data_str =  data_str.replaceAll(";"," ");
        data_str =  data_str.replaceAll(","," ");
        data_str =  data_str.replaceAll("\\+"," ");
        data_str =  data_str.replaceAll("-"," ");
        data_str =  data_str.replaceAll(">"," ");
        data_str =  data_str.replaceAll("<"," ");
        data_str =  data_str.replaceAll("\\."," ");
        data_str =  data_str.replaceAll("="," ");
        data_str =  data_str.replaceAll("，"," ");
        data_str =  data_str.replaceAll(":"," ");

        data_str = data_str.replaceAll(" {2,}", " ");
        data_str = data_str.trim();

        String []ret = data_str.split(" ");

        HashMap<String,Integer> map = new HashMap<String,Integer>();

        for(String s : ret){
            for(String keyword:keyWord){
                if(s.equals(keyword)){
                    map.put(keyword,0);
                    break;
                }
            }
        }

        Set<String> keySet = map.keySet();
        Object[] key_array = keySet.toArray();
        Arrays.sort(key_array);

        for(Object s:ret){
            for(String word:keyWord){
                if(s.equals(word)) {
                    map.put(word,map.get(word)+1);
                    break;
                }
            }
        }

        for(Object s:key_array){
            System.out.println(map.get(s)+"\t"+s);
        }
    }
}

10.1

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashMap<String,String[]> map = new HashMap<String,String[]>();

        while(true){
            String line = sc.nextLine();
            if(line.equals("end")) break;

            String[] data = line.split(" ");
            String key = data[0];
            String[] value = {data[1],data[2]};

            map.put(key,value);
        }

        String sid_str = sc.nextLine();
        if(map.containsKey(sid_str)){
            System.out.println(sid_str+" "+map.get(sid_str)[0]+" "+map.get(sid_str)[1]);
        }else System.out.println("The student "+sid_str+" does not exist");
    }
}

10.2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashMap<String,String[]> map = new HashMap<String,String[]>();

        while(true){
            String line = sc.nextLine();
            if(line.equals("end")) break;

            String[] data = line.split(" ");
            String key = data[0];
            String[] value = {data[1],data[2]};

            map.put(key,value);
        }

//        String sid_str = sc.nextLine();
//        if(map.containsKey(sid_str)){
//            System.out.println(sid_str+" "+map.get(sid_str)[0]+" "+map.get(sid_str)[1]);
//        }else System.out.println("The student "+sid_str+" does not exist");
        Set<String> keySet = map.keySet();
        String[] key_array = keySet.toArray(new String[0]);
        Arrays.sort(key_array, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });


        for(String key:key_array){
            System.out.println(key+" "+map.get(key)[0]+" "+map.get(key)[1]);
        }
    }
}

10.4

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
public static void speak(Animal animal) {
    animal.shout();
}
}

//定义抽象类Animal
abstract class Animal {
    abstract public String getAnimalClass();

    abstract public void shout();
}

//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal {
    @Override
    public String getAnimalClass() {
        return "Cat";
    }

    @Override
    public void shout() {
        System.out.println("猫的叫声：喵喵");
    }
}

//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
    @Override
    public String getAnimalClass() {
        return "Dog";
    }

    @Override
    public void shout() {
        System.out.println("狗的叫声：汪汪");
    }
}

//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {
    @Override
    public String getAnimalClass() {
        return "Goat";
    }

    @Override
    public void shout() {
        System.out.println("山羊的叫声：咩咩");
    }
}

11.1

import java.util.*;


public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        ArrayList<Student> students = new ArrayList<Student>();
        while(true){
            String line = sc.nextLine();
            if(line.equals("end")) break;

            String[] data = line.split(" ");

            int sid = Integer.parseInt(data[0]);
            String name = data[1];
            int math_score = Integer.parseInt(data[2]);
            int pht_score = Integer.parseInt(data[3]);

            students.add(new Student(sid, name, math_score, pht_score));
        }

        students.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.get_score_sum()-o1.get_score_sum();
            }
        });

        for (Student student : students) System.out.println(student.getSid()+" "+student.getName()+" "+ student.get_score_sum());

    }
    public static class Student {
    private int sid;
    private String name;
    private int math_score;
    private int phy_score;

    public int get_score_sum(){
        return this.math_score+this.phy_score;
    }


    public Student() {
    }

    public Student(int sid, String name, int math_score, int phy_score) {
        this.sid = sid;
        this.name = name;
        this.math_score = math_score;
        this.phy_score = phy_score;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

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

    public int getMath_score() {
        return math_score;
    }

    public void setMath_score(int math_score) {
        this.math_score = math_score;
    }

    public int getPhy_score() {
        return phy_score;
    }

    public void setPhy_score(int phy_score) {
        this.phy_score = phy_score;
    }
}

}

11.3

import java.util.*;


public class Main {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();
        Scanner sc=new Scanner(System.in);
        int n = sc.nextInt();
        String l = sc.nextLine();
        for(int i=0; i<n; i++) {
            String line = sc.nextLine();
            arr.add(line);
        }
        while(true){
            String line = sc.nextLine();
            if(line.equals("sort1")){
                arr.sort(new Comparator<String>() {
                    @Override
                    public int compare(String o1, String o2) {
                        String s1 = o1.substring(6,14);
                        String s2 = o2.substring(6,14);

                        return s1.compareTo(s2);
                    }
                });
                for(int i=0; i<arr.size(); i++){
                    String temp = arr.get(i);
                    System.out.println(temp.substring(6,10)+"-"+temp.substring(10,12)+"-"+temp.substring(12,14));
                }
            }else if(line.equals("sort2")){
                arr.sort(new Comparator<String>() {
                    @Override
                    public int compare(String o1, String o2) {
                        String s1 = o1.substring(6,14);
                        String s2 = o2.substring(6,14);

                        return s1.compareTo(s2);
                    }
                });
                for(int i=0; i<arr.size(); i++){
                    String temp = arr.get(i);
                    System.out.println(temp);
                }
            }else {
                System.out.println("exit");
                break;
            }
        }
    }

}

11.4

import java.util.*;


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ArrayIntegerStack ais = new ArrayIntegerStack(n);
        int m = sc.nextInt();
        for(int i = 0; i <m;i++){
            int x = sc.nextInt();
            Integer y = ais.push(x);
            System.out.println(y);
        }
        System.out.println(ais.peek()+","+ais.empty()+","+ais.getSize());
        System.out.println(Arrays.toString(ais.arr));

        int o = sc.nextInt();
        for(int i = 0; i < o;i++){
            Integer pop = ais.pop();
            System.out.println(pop);
        }
        System.out.println(ais.peek()+","+ais.empty()+","+ais.getSize());
        System.out.println(Arrays.toString(ais.arr));
    }
public static class ArrayIntegerStack implements IntegerStack{
    private int max_capacity;
    Integer []arr;
    private int size = 0;

    public ArrayIntegerStack() {
        this.max_capacity = 100;
        arr = new Integer[max_capacity];
    }
    public ArrayIntegerStack(int max_capacity) {
        this.max_capacity = max_capacity;
        arr = new Integer[max_capacity];
    }

    public void size_increment(){
        this.setSize(this.getSize()+1);
    }
    public void size_degress(){
        this.setSize(this.getSize()-1);
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public Integer peek() {
       if(this.empty()) return null;
        return arr[size-1];
    }

    @Override
    public Integer pop() {
        if(this.empty()) return null;
        int x = this.peek();
        // arr[size-1] = null;
        this.size_degress();
        return x;
    }

    @Override
    public Integer push(Integer item) {
        if(item==null||this.size==max_capacity){
            return null;
        }
        arr[size] = item;
        this.size_increment();
        return item;
    }

    @Override
    public boolean empty() {
        return size == 0;
    }

    @Override
    public int size() {
        return this.getSize();
    }
}
public interface IntegerStack {
    public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

    public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer peek();  //获得栈顶元素，如果为空，则返回null.
    public boolean empty(); //如果为空返回true
    public int size();      //返回栈中元素个数
}

}

11.5

import java.util.*;


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n1 = sc.nextInt();
        String x = sc.nextLine();
        ArrayList<PersonOverride> persons1 = new ArrayList<PersonOverride>();
        for(int i = 0; i < n1;i++){
            persons1.add(new PersonOverride());
        }

        int n2 = sc.nextInt();
        String y = sc.nextLine();
        ArrayList<PersonOverride> persons2 = new ArrayList<PersonOverride>();

        for(int i= 0;i<n2;i++){
            String line = sc.nextLine();
            String[] data = line.split(" ");
            String name = data[0];
            int age = Integer.parseInt(data[1]);
            boolean gender = Boolean.parseBoolean(data[2]);

            PersonOverride po = new PersonOverride(name, age, gender);
            boolean flag = false;
            for(PersonOverride p: persons2){
                if(p.equals(po)){
                    flag = true;
                    break;
                }
            }

            if(!flag){
                persons2.add(po);
            }
        }

        for(PersonOverride p: persons1) System.out.println(p);
        for(PersonOverride p: persons2) System.out.println(p);
        System.out.println(persons2.size());
           System.out.println("[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]");
        // System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
public static class PersonOverride {
    private String name;
    private int age;
    private boolean gender;

    @Override
    public String toString() {
        return this.name+"-"+this.age+"-"+this.gender;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        PersonOverride that = (PersonOverride) o;

        if (age != that.age) return false;
        if (gender != that.gender) return false;
        return name != null ? name.equals(that.name) : that.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        result = 31 * result + (gender ? 1 : 0);
        return result;
    }

    public PersonOverride() {
        this("default",1,true);
    }

    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }
}

}

二.分析与设计

　　第七次是之前的迭代，没什么好说的，所以跳过。

　　8.1：课程成绩统计程序-1。

　　　　设计思路也没什么特殊的，都是大同小异。需要注意的就是那些异常处理，还有就睡必修课一定对应的考试，不能对应考察，考试有两种成绩，期中成绩和期末成绩，考查只有期末成绩，注意了这些后都没说明特殊的。

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

　　　　和前言中说的一样，主要是一些数据清洗的过程，以及正则表达式的使用，需要注意的是在数据清洗过程中要把一些特殊字符处理掉，同时也要同意格式，主要也就是要去除单词与单词之间多余的空格，否则在使用split（）分割后获得的单词会带有空格，从而导致用正则表达式匹配失败的情况。

 　　10.1容器-HashMap-检索.

　　　　我们需要储存的值有三个，分别是学号，姓名和成绩。而理论上键值对只能分别储存key和value两个。首先可以确定key，因为key有着unique的特性，不能重复，这一点和学号一样，所以可以确定key就是用来储存学号，所以姓名和成绩就放在value中，但是姓名和成绩是有两个值，我们怎么储存进value中？我最开始的想法是使用嵌套的map，也就是说在最外层的map的value中再储存一个map，但此时内层的这个map的key和value就不好对应了，因为姓名和成绩都有可能会重复，于是这种想法便被pass了。所以我采用的是第二种方法，用字符串数组来储存姓名和学号，决定好这些后接下来就没什么难的了。

　　10.2 容器-HashMap-排序.

　　　　相比于第一题也就只是多了一个map的排序，就和前言中说的一样，首先确定好是要对key排序还是要对value排序，确定好之后再取出对应的set，使用toArray()转化成数组，再调用Arrays中的sort（）方法，可以根据需要重写sort（）中的比较器方法从而实现自定义排序。

　　10.4动物发声模拟器（多态）。

　　　　最基础的多态的用法，没什么多说的。

　　11.1容器-ArrayList-排序.

　　　　和之前的map排序不同，这次的更加简单，直接调用ArrayList自带的sort（）方法，根据需要重写sort（）中的比较器即可。

　　11.3jmu-Java-02基本语法-03-身份证排序.

　　　　和上一题一样，也是ArrayList的排序。

　　11.4jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack 

　　　　主要是对栈的实现，梳理一遍栈的push（）和pop（）就没什么问题，然后要注意要设置一个size来记录栈中的数据的数量，同时注意pop（）不能真的把数据从底层删除，只要移动指针，改变size的值即可。

　　11.5jmu-Java-03面向对象基础-05-覆盖

　　　　对Object中的equals（）和toString（）重写，剩下的没有难点。

三.踩坑心得

　　首先就是9.1这道有关数据清洗的题目：统计Java程序中关键词的出现次数。我没有对数据进行彻底的清洗，有很多特殊字符需要进行处理，但是往往会忘掉几个需要处理的特殊字符，所以在答案结果出问题的时候可以先输出看看清洗后的数据的样子，看看是否符合心中所想的。如果不是，那大概率就是梳理特殊字符的时候出现的问题了。

　　然后是10.1容器-HashMap-检索.在写题目前一定要确定好一些重要的地方该怎么写，就比如说之前分析的key和value如何储存对应的三个值，剩下的没什么好说的了。

　　11.4jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack.这道题我还写了挺久的，主要是在pop（）中出现了问题，我最开始是将需要删除的数据从底层彻底remove，最终得出的结果却和样例中的结果不一样，起初我还以为是样例的错，在思考过后才想到不能将底层的数据彻底删除，只要改变size的值就好。

　　

四.改进建议　　

　　　在遇到瓶颈的时候不要一直死扣那一道题，有一句话我觉得说的很好，不能在一棵树上吊死，当我们遇到写不出来的题目时，可以换到题目写，在不然去做些其他的事情也可以，状态也很重要，有时候当我们休息过后，将状态调整过来也许就会有了新的发现，新的认识。

　　第二点就是最好不要去在网上查看相关的题目，有时候多想想也许就会有正确的思路。就比如说数据清洗这道题目，我就是在网上先看了别人的思路，不能说自己一点思路都没有，但当时确实是想看看自己的思路是不是正确的，和其他人的思路会不会有太大的偏差。但其实这些题目都是没有标准答案的，别人的正解，别人的思路还真不一定会比自己的好，有时也就应该多努力一下，说不定自己的思路自己的解法也一样正确。

 

五.总结

　　本次blog对应的题目集数量较多，所以这次blog所写的内容也较多。和之前一直迭代菜单的题目不同，这几次pta作业中有很多次都加入了一些新的考察知识点，比如说map的储存，map的排序，ArrayList的储存，ArrayList的排序，自定义类的编写，自定义Stack的实现，Object类中equals（）和toString（）方法的重写，多态的使用以及数据的清洗和正则表达式的使用，等等知识点，相比于之前一直迭代菜单，这几次的pta让我学到了很多，让我收获很多，也让我认识到了自身的很多不足，总的来说，这几次的pta习题让我受益匪浅！