结队编程--java实现

1、GitHub地址：https://github.com/caiyouling/Myapp

队友:钟小敏 GitHub地址：https://github.com/zhongxiao136/Myapp

2.PSP表格

PSP	Personal Software Process Stages	预计耗时(分钟)	实际耗时(分钟)
Planning	计划	40	30
.Estimate	.估计这个任务需要多少时间	40	30
Development	开发	1320	1330
.Analysis	.需求分析	100	120
.Design Spec	.生成设计文档	40	30
.Design Review	.设计复审	15	20
.Coding Standard	.代码规范	15	20
.Design	.具体设计	90	100
.Coding	.具体编码	850	950
.Code Review	.代码复审	90	90
.Test	.测试(自我测试，修改代码，提交修改)	120	130
Reporting	报告	180	160
.Test Report	.测试报告	90	80
.Size Measurement	.计算工作量	30	40
.Postmortem&Process Improvement Plan	.事后总结，并提出过程改进计划	60	40
合计		1540	1520

效能分析

设计实现过程

解题思路：由于题目为自动生成小学四则运算题目，所以需要系统随机生成运算式。运算式包含操作数和运算符，所以我们就用了一个CreateNumAndOpe类随机生成，然后利用createExpression类组合成运算式和答案(利用Calculate类进行计算，因为结果要为真分数或整数，所以我们利用Fraction类对分数进行操作化为最终形式)，然后用createFile类生成题目，答案和做题文件，最后，利用Grade类进行验证答案，并生成成绩文件。
createNumAndOpe类：定义运算符数组；包含createNumber()和createOperator(),其中createNumber()用于生成操作数(利用Random类随机生成整数或分数)；createOperator()用于生成运算符，随机从运算符数组中选出运算符。
createExpression类：用于生成随机带括号的运算式，其中exerciseAndAnswer()根据操作数数组和运算符数组生成运算式，其中需要用Random类判断是否随机生成括号，最后用Calculate()计算出结果。getExerciseAndAnswer()根据用户输入的题目个数和数字范围生成相应的题目和答案。
Calculate类：根据运算式转为字符数组，然后逐个遍历，建立一个运算符栈和操作数栈，利用中缀表达式转为后缀表达式进行计算。

因为括号的优先级最高，所以我们先判断是否为'(',若是则入运算符栈；
判断是否为')',是则从操作数取出两个进行运算，将'('之后的运算符都拿出来算，结果再存入操作数栈中，然后左括号出栈；
判断是否为运算符，当运算符优先级小于运算符栈顶元素，则取两个操作数进行运算，直至栈顶优先级不高于该运算符，结果存入操作数栈中，然后该运算符入栈；
若为操作数，因为生成的操作数有分数，但是我们转为了字符数组，就需要根据'/'作为标志获取分子和分母，若为整数，我们将分母设为1，把操作数都转为分数进行传到calculate()进行运算，返回结果

Fraction类：对分数进行操作，其中getFinalFraction()用于生成最终分数形式，gcd()利用辗转相除法生成最大公约数，getRealFraction()将假分数转为真分数。
createFile类：利用System.getProperTy()获取当前路径生成printFile文件夹，利用BufferedWriter写入题目文件，答案文件和答题文件(用户进行答题的文件)，存放到printFile文件夹下
Grade类：用于验证用户答题是否正确，利用BufferedReader读取Writer文件和answer文件进行比较，算出对错的题数及题号写入Grade文件，也存在printFile文件夹下。
各类之间的调用如下：
Frame类：图形化界面，用户点击‘生成文件’，即会生成练习文件，在左面板也会出现题目，中间面板进行答题，点击查看答案，则会有正确答案在右侧面板，查看成绩后会弹出成绩框。

关键代码说明

用于生成操作数和运算符的方法：1.利用随机生成的flag=[0,1]，当flag为0时，生成整数 2.当flag为1时，生成分子和分母组成分数

public static String[] createNumber(int number, int round){

        Random random = new Random();
        String[] num = new String[number];

        for (int i = 0; i < number; i++) {
            //用于判断生成整数还是分数
            int flag = (int)(Math.random()*10) % 2;
            if(flag == 0){          //生成整数
                int n = random.nextInt(round);
                if(n == 0){
                    num[i] = 1 + "";
                }else{
                    num[i] = n +"";
                }
            }else{          //生成分数
                //随机生成分子和分母
                int numerator = random.nextInt(round);
                int denominator = random.nextInt(round);;
                while(numerator>=denominator || numerator==0 || denominator==0){    //判断是否为真分数，且不能生成带0的分数
                    numerator = random.nextInt(round);
                    denominator = random.nextInt(round);
                }
                //拼装成分数形式
                num[i] = numerator + "/" + denominator;
            }
        }
        return num;
    }

    /**
     * 随机生成运算符
     * 将四则运算符放入一个静态不可变的operatorTypes[]字符数组中
     * 随机产生index到数组中取操作符
     */
    private static final Character[] operatorTypes = {'+' , '-' , '×' , '÷'};

    public static Character[] createOperators(int number) {
        Character[] operators = new Character[number];
        for (int i = 0; i < number; i++) {
            //随机获取运算符的类型(0~3 代表4个运算符(+、-、×、÷)的类型)
            int index = (int)(Math.random()*4);
            Character operatorType = operatorTypes[index];
            operators[i] = operatorType;
        }
        return operators;
    }
     public static int priority(Character character) {
        switch(character) {

            case '×':
            case '÷':return 1;
            case '+':
            case '-':return 0;
        }
        return -1;
    }
    
     private static String[] exerciseAndAnswer(String[] numbers, Character[] operators){

        Random random = new Random();
        //获得操作数的数量
        int num = numbers.length;
        //随机生成带括号的算式
        int isAddBracket = (int)(Math.random()*10) %2;
        if(isAddBracket ==  1){    //当isAddBracket==1时，生成带括号的表达式
            //当标记为1时代表该操作数已经添加了左括号
            int[] leftBracket = new int[num];
            //当标记为1时代表该操作数已经添加了右括号
            int[] rightBracket = new int[num];
            //遍历操作数数组，随机添加括号
            for (int index = 0 ; index<num-1 ; index++) {
                int n = (int)(Math.random()*10)%2;
                if(n == 0 && rightBracket[index] != 1) {//判断当前操作数是否标记了左括号
                    leftBracket[index] = 1;     //标记已生成左括号
                    numbers[index] = "(" + numbers[index];  //操作数之前加上左括号
                    int k = num - 1;
                    //生成右括号的位置（左括号的位置~最后）
                    int rightBracketIndex = random.nextInt(k)%(k-index) + (index+1);
                    //如果当前操作数有左括号，则重新生成括号位置
                    while (leftBracket[rightBracketIndex] == 1){
                        rightBracketIndex = random.nextInt(k)%(k-index) + (index+1);
                    }
                    rightBracket[rightBracketIndex] = 1;        //标记已生成右括号
                    numbers[rightBracketIndex] = numbers[rightBracketIndex] +")";
                }
            }
        }
        //将运算符数组和操作数数组交替拼成一个算式字符串
        StringBuilder str = new StringBuilder(numbers[0]);
        for (int k = 0; k < operators.length; k++) {     //组成算式
            str.append(operators[k]).append(numbers[k + 1]);
        }
        //将算式转换为String
        String exercise = str.toString();
        //获取运算式结果
        String answer = Calculate.getAnswer(exercise);
        if(answer.equals("-")){      //运算过程出现负数则返回null
            return null;
        }
        return new String[]{exercise,answer};
    }

public static String getAnswer(String expression) {

        Stack<Character> operators = new Stack<Character>();  //运算符栈，用于存放运算符
        Stack<Fraction> fractions = new Stack<Fraction>();  //操作数栈,用于存放操作数
        if(expression == null){
            return "null";
        }
        char[] chars = expression.toCharArray();   //将表达式字符串转成字符数组
        //遍历获取处理
        for (int i = 0 ; i<chars.length ; i++) {
            char c = chars[i];
            if(c == '('){             //先处理有括号的情况，如果是左括号，入栈
                operators.push(c);
            }   else if(c == ')'){           //当前字符为右括号
                while(operators.peek() != '('){   //当运算符栈顶的元素不为‘(’,则继续

                    Fraction fraction1 = fractions.pop();   //拿取操作栈中的两个分数
                    Fraction  fraction2 = fractions.pop();
                    //获取计算后的值
                    Fraction result = calculate(operators.pop(), fraction1.getNumerator(), fraction1.getDenominator(),
                            fraction2.getNumerator(), fraction2.getDenominator());
                    if(result.getNumerator()<0){            //判断是否为负数
                        return  "-";
                    }
                    //将结果压入栈中
                    fractions.push(result);
                }
                //将左括号出栈
                operators.pop();
            }else if(isOperator(c)){//是运算符
                //当运算符栈不为空，且当前运算符优先级小于栈顶运算符优先级
                while(!operators.empty() && !(priority(c)>= priority(operators.peek()))){
                    //拿取操作栈中的两个分数
                    Fraction fraction1 = fractions.pop();
                    Fraction  fraction2 = fractions.pop();
                    //获取计算后的值
                    Fraction result = calculate(operators.pop(), fraction1.getNumerator(), fraction1.getDenominator(),
                            fraction2.getNumerator(), fraction2.getDenominator());
                    if(result.getNumerator()<0){
                        return  "-";
                    }
                    //将结果压入栈中
                    fractions.push(result);
                }
                //将运算符入栈
                operators.push(c);
            }else{          //是操作数
                if(c >= '0' && c <= '9'){
                    StringBuilder fra = new StringBuilder();
                    //对分式进行处理
                    while(i<chars.length && (chars[i]=='/' || ((chars[i]>='0') && chars[i]<='9'))){
                        fra.append(chars[i]);
                        i++;
                    }
                    i--;
                    //到此 fra里面是一个操作数
                    String val = fra.toString();
                    //标记‘/’的位置
                    int flag = val.length();
                    for(int j = 0 ; j<val.length() ; j++){
                        if(val.charAt(j)=='/'){//当获取的数值存在/则标记/的位置，便于接下来划分分子和分母生成分数对象
                            flag = j;
                        }
                    }
                    //把操作数拆成分式计算
                    //分子
                    StringBuilder numeratorBuf = new StringBuilder();
                    //分母
                    StringBuilder denominatorBuf = new StringBuilder();
                    for(int k = 0 ; k<flag; k++){
                        numeratorBuf.append(val.charAt(k));
                    }
                    //判断是否为分数
                    if(flag != val.length()){
                        for(int m = flag+1 ; m<val.length() ; m++){
                            denominatorBuf.append(val.charAt(m));
                        }
                    }else{//如果不是分数则分母计为1
                        denominatorBuf.append('1');
                    }
                    //将分子分母分别入栈
                    fractions.push(new Fraction(Integer.parseInt(numeratorBuf.toString()),
                            Integer.parseInt(denominatorBuf.toString())));
                }
            }
        }
        while(!operators.empty() && fractions.size()>1){

            Fraction fraction1 = fractions.pop();
            Fraction  fraction2 = fractions.pop();
            //获取计算后的值
            Fraction result = calculate(operators.pop(), fraction1.getNumerator(), fraction1.getDenominator(),
                    fraction2.getNumerator(), fraction2.getDenominator());
            if(result.getNumerator()<0){
                return "-";
            }
            //将结果压入栈中
            fractions.push(result);
        }
        //计算结果
        Fraction result = fractions.pop();
        //获取最终的结果(将分数进行约分)
        return Fraction.getFinalFraction(result);
    }
    //用于验证答案是否正确，correct的题数用字符串拼接，再分割字符串
     public static void isAnswer(String writeFilePath, String answerFilePath) {
        //获取用户答题和练习答案的文件
        File writeFile = new File(writeFilePath);
        File answerFile = new File(answerFilePath);
        //找到存放Writer.txt和Answer.txt文件的文件夹
        String fileDirectory = System.getProperty("user.dir") + File.separator + "PrintFile";
        File gradeFile = new File(fileDirectory, "Grade.txt");//在当前文件夹下生成Grade.txt文件
        if(writeFile.isFile() && answerFile.isFile()) {
            try {
                BufferedReader writeReader = new BufferedReader(new InputStreamReader(new FileInputStream(writeFile)));
                BufferedReader answerReader = new BufferedReader(new InputStreamReader(new FileInputStream(answerFile)));
                //储存错题和对题
                String correct = "";
                String wrong = "";
                int correctNum = 0;
                int wrongNum = 0;
                //记录错题对题的题号
                int index = 1;
                String write = null;
                String answer = null;
                System.out.println("开始验证答案···");
                //通过一行行读取文件比较答题情况
                while((( write= writeReader.readLine()) != null) && ((answer = answerReader.readLine()) != null)){
                    if(write.equals(answer)){
                        //将答对的题用字符串拼接
                        correct += "," + index;
                        index ++;
                        correctNum ++;
                    }else{
                        wrong += "," + index;
                        index ++;
                        wrongNum ++;
                    }
                }
                //用于生成Grade.txt文件内容
                if(correctNum > 0){
                    correct = "Correct: " + correctNum + "(" + correct.substring(1) +")" + "\r\n" ;
                }else{
                    correct = "Correct: 0" +"\r\n";
                }
                if(wrongNum > 0){
                    wrong = "Wrong: " + wrongNum +  "(" + wrong.substring(1) +")";
                }else{
                    wrong = "Wrong: 0";
                }
                //写入文件
                BufferedWriter gradeFileBuf = new BufferedWriter(new FileWriter(gradeFile));
                gradeFileBuf.write(correct);//将correct 和wrong写入文件
                gradeFileBuf.write(wrong);
                System.out.print(correct);//控制台也打印答题情况
                System.out.println(wrong);
                if(writeReader != null){
                    writeReader.close();
                }
                if(answerReader != null){
                    answerReader.close();
                }
                if(gradeFileBuf != null){
                    gradeFileBuf.close();
                }
                 public static String getFinalFraction(Fraction fraction) {
        int denominator = fraction.getDenominator();        //获得分子分母
        int numerator = fraction.getNumerator();
        if(numerator == 0){ //若分子为0，则输出0
            return "0";
        }
        if(denominator == 0){
            return "";
        }
        int a = gcd(numerator, denominator);        //c是分子分母的最大公因数，将分子分母化简
        if (denominator == 1 ) {   //分母为1
            return numerator + "";
        }
        if(numerator == denominator){
            return 1+"";
        }else {
            if(numerator > denominator){           //分子大于分母化为真分数
                fraction = getRealFraction(fraction);   //假分数分割为商和余数，余数作为新的分子
                if(fraction.getNumerator() == 0){//若余数为0，则代表整除
                    return fraction.getInter()+"";
                }else {
                    return fraction.getInter() + "'" + fraction.getNumerator()/a + "/" + fraction.getDenominator()/a;
                }
            }else{              //其他情况化简分数
                return numerator/a + "/" + denominator/a;
            }
        }
    }
    private static int gcd(int numerator, int denominator){
        if(numerator%denominator == 0){
            return denominator;         //获取最大公因数
        }else{
            return gcd(denominator,numerator%denominator);    //辗转相除法递归获取最大公因数
        }
    }

测试

1.启动main，运行控制台打印

2.用户输入后生成的文件列表
.
3.生成题目文件的题目

4.生成答案放入文件

5.在答题文件进行答题后

6.重新判别答案

7.传入参数不正确的情况

8.输入不正确的文件名

9.生成一万道题目

10.生成一万道题目的答案文件

11.初始界面

12.点击生成文件

13.输入生成个数

14.生成题目

15.进行作答

16.输出成绩

17.生成十道题

18.生成一万道