可以算数的四则运算

import java.util.Random;
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class siziyunsuan {

    public static boolean text(String[] str1,String temp)
    {
        //存贮第二个？  str1.equals(str2)；

        if(str1.equals(temp))
        {
            return false;
        }
        //判断第一个和第二个是否相同，第三个和第二个，第一个相同

        //如果相同的话，int i = ans,i--，在继续输出j = ans - i个

        //如果ans == i就直接输出
        return true;
    }

    public static BigDecimal 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;
// 1. 将中缀表达式转换为后缀表达式
        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());
        }
// 2.计算后缀表达式的值
        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();
    }


    public static void main(String[] args) {
        Random random = new Random();
        String str[] = new String[30];

        //定制数量
        int x;
        System.out.println("输入制定个数");
        Scanner sc = new Scanner(System.in);
        x = sc.nextInt();

        //打印多少
        int ans;
        System.out.println("请输入想打印多少");
        ans = sc.nextInt();

        //最大值
        int len;
        System.out.println("请输入最大值范围");
        len = sc.nextInt();
        int random1;

        int j = 0;
        int re1 = 0;//记录正确个数

        //System.out.println(chark);
        while (j <= ans) {
            int houhou = 0;

            String temp = new String();
            for (int i = 0; i < (2 * x )- 1; i++) {
                if (i % 2 == 0) {
                    int p = random.nextInt(len) + 1;
                    temp += Integer.toString(p);

                }
                else {
                    switch (random.nextInt(4)) {
                        case 0:
                            temp += '+';

                            break;
                        case 1:
                            temp += '-';

                            break;
                        case 2:
                            temp += '*';

                            break;
                        case 3:
                            temp += '/';

                            break;
                    }
                }


            }
//            if(houhou != 0)
//                System.out.print(")");
 //             j++;
//            System.out.println();
            if(text(str,temp))
            {
                str[j] = temp;
                j++;

                System.out.println(temp);
                BigDecimal result1 = new BigDecimal(sc.next());
                BigDecimal result = cal(temp);

                if(result1.equals(result))
                {
                    System.out.println("恭喜你答对了");
                    re1++;
                }
                else
                {
                    System.out.println("回答错误");
                }
            }

        }
        System.out.println("正确率：" + String.format("%.2f", (re1 *0.1)/ans*10));
    }
}