周总结5

这周研究了结对开发的四则运算

package com.az.test.calc;

import java.util.Scanner;


import com.az.test.calc.CreateShiZi;
import com.az.test.calc.NiBoLanShi;

public class Student {

    public static void main(String[] args) {
        CreateShiZi createShiZi = new CreateShiZi();
        NiBoLanShi niBoLanShi = new NiBoLanShi();
        String[] fuHao = {"+","-","*","/"};
        Scanner input = new Scanner(System.in);
        System.out.println("请输入范围内的计算：");
        int m = input.nextInt();
        System.out.println("请输入要产生的题数：");
        int n = input.nextInt();
        String[] strArray = new String[n];
        System.out.println("
题目
");
        createShiZi.create(m, n, fuHao, strArray);
        for(int i = 0; i<n; i++) {
            String result = niBoLanShi.cal(strArray[i]);
            System.out.println("第"+(i+1)+"题："+strArray[i]);
            System.out.print("你的答案：");
            String yourAnswer = input.next();
            if (yourAnswer.equals(result)) {
                System.out.println("True
");
            }else {
                System.out.println("False");
                System.out.println("正确答案："+result+"
");
            }
        }
    }
}

package com.az.test.calc;

import java.util.List;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Stack;

public class NiBoLanShi {
    public static String cal(String str) {
        //对表达式进行预处理，并简单验证是否是正确的表达式
        //存放处理后的表达式
        List<String> list = new ArrayList<>();
        char[] arr = str.toCharArray();
        
        //存放数字临时变量
        StringBuffer tmpStr = new StringBuffer();
        for (char c : arr) {
            //如果是数字或小数点，添加到临时变量中
            if (c>='0' && c<='9') {
                tmpStr.append(c);
            }else if(c=='.') {
                if(tmpStr.indexOf(".")>0) {
                    throw new RuntimeException("非法字符");
                }
                tmpStr.append(c);
            }
            
            //如果是加减乘除或者括号，将数字临时变量和运算符依次放入List中
            else if (c=='+' || c=='-' || c=='*' || c=='/' || c=='(' || c==')') {
                if (tmpStr.length() > 0) {
                    list.add(tmpStr.toString());
                    tmpStr.setLength(0);
                }
                list.add(c + "");
            }
            else if (c==' ') {
                continue;
            }
            else {
                throw new RuntimeException("非法字符");
            }
        }
        if (tmpStr.length() > 0) {
            list.add(tmpStr.toString());
        }
        
        //初始化后缀表达式
        List<String> strList = new ArrayList<>();
        
        //运算过程中，使用了两次栈结构，
        //第一次是将中缀表达式转换成后缀表达式，第二次是计算后缀表达式的值
        Stack<String> stack = new Stack<>();
        
        //声明临时变量，存放栈元素
        String tmp;
        
        //将中缀表达式转换成后缀表达式
        for (String s : list) {
            //如果是左括号直接入栈
            if (s.equals("(")) {
                stack.push(s);
            }
            
            //如果是右括号，执行出栈操作，依次添加到后缀表达式中，直到出栈元素为左括号，左括号和右括号都不添加到后缀表达式中
            else if (s.equals(")")) {
                while (!(tmp = stack.pop()).equals("(")) {
                    strList.add(tmp);                    
                }
            }
            
            //如果是加减乘除，弹出所遇优先级大于或等于该运算符的栈顶元素（栈中肯定没有右括号，认为左括号的优先级最低），然后将该运算符入栈
            else if (s.equals("*") || s.equals("/")) {
                while(!stack.isEmpty()) {
                    //取出栈顶元素
                    tmp = stack.peek();//取出但不移除
                    if (tmp.equals("*") || tmp.equals("/")) {
                        stack.pop();
                        strList.add(tmp);
                    }
                    else {
                        break;
                    }
                }
                stack.push(s);
            }
            else if (s.equals("+") || s.equals("-")) {
                while(!stack.isEmpty()) {
                    //取出栈顶元素
                    tmp = stack.peek();
                    if (!tmp.equals("(")) {
                        stack.pop();
                        strList.add(tmp);
                    }
                    else {
                        break;
                    }
                }
                stack.push(s);
            }
            
            //如果是数字，直接添加到后缀表达式中
            else {
                strList.add(s);
            }
        }
        
        //最后依次出栈，放入后缀表达式中
        while (!stack.isEmpty()) {
            strList.add(stack.pop());
        }
        
        //计算后缀表达式的值
        Stack<BigDecimal> newStack = new Stack<>();
        for (String s : strList) {
            //若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符的左边
            //运算后的结果再进栈，直到后缀表达式遍历完毕
            if (s.equals("*") || s.equals("/") || s.equals("+") || s.equals("-")) {
                BigDecimal b1 = newStack.pop();
                BigDecimal b2 = newStack.pop();
                switch (s) {
                case "+":
                    newStack.push(b2.add(b1));
                    break;
                case "-":
                    newStack.push(b2.subtract(b1));
                    break;
                case "*":
                    newStack.push(b2.multiply(b1));
                    break;
                case "/":
                    newStack.push(b2.divide(b1, 9, BigDecimal.ROUND_HALF_UP));
                    break;
                }
            }
            
            //如果是数字，入栈
            else {
                newStack.push(new BigDecimal(s));
            }
        }
        
        //最后，栈中仅有一个元素，就是计算结果
        return newStack.peek().toString();
    }
}

package com.az.test.calc;


public class CreateShiZi {
    public void create(int m, int n, String[] fuHao, String[] strArray) {
        String str = "";
        
        //随机生成式子
        for (int i = 0; i < n; i++) {
            str = "";
            int[] arr1 = new int[n];
            int[] arr2 = new int[n];
            arr2[i] = (int)(Math.random()*m+1);
            for(int j = 0; j < (int)(Math.random()*10+1); j++) {
                int order = (int)(Math.random()*4);
                arr1[j] = (int)(Math.random()*m+1);
                str = str + arr1[j] + fuHao[order];
            }
            str = str + arr2[i];
            strArray[i] = str;
            System.out.println("第"+(i+1)+"题："+str);
            arr1 = null;
            arr2 = null;
        }
        System.out.println("
");
    }
}