四则运算

源码：

Arithmetic：

package arithmetic;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 四则运算
 *
 * @author lilongrong
 * @version 2020/3/28
 * @
 */

public class Arithmetic {
    private String arithmetic;

    //public ArrayList<Character> rpnArr = new ArrayList<>(); //用于存储逆波兰式
    private int flag = 0;   //用于记录存储的顺序
    private Map<Integer, Integer> intMap = new HashMap<>();  //用于存储数字
    private Map<Integer, Character> charMap = new HashMap<>();  //用于存储运算符
    private Map<Character, Integer> map = new HashMap<>();    /*用于存四则运算符号的优先级*/
    private ArrayList<Integer> sum = new ArrayList<>();   /*可能不是一位数字，那么就需要对每个数字线存储起来，遇到符号时就将存储起来的数字进行运算*/
    private Stack<Character> stack = new Stack<>();   /*存储四则运算的符号*/
    private int add = 0;

    /**
     *input a kind String expression,and then output a kind of int result.
     *
     *
     * @param arithmetic expression like "6+(8-7)+5*6+9-12/2"
     */
    public Arithmetic(String arithmetic)
    {
        this.arithmetic = arithmetic;
    }


    /*对每个字符进行相应的处理*/
    private void analyze(String arithmetic) throws ArithmeticHandleException
    {
        /*定义四则运算符号的优先级*/
        map.put('+', 1);
        map.put('-', 1);
        map.put('*', 2);
        map.put('/', 2);
        map.put('(', 3);
        map.put(')', 3);

        for (int i = 0; i < arithmetic.length(); i++)
        {
            char nowChar = arithmetic.charAt(i);    /*取出第一个字符*/
            if (nowChar == '+' || nowChar == '-' || nowChar == '*' || nowChar == '/' || nowChar == '(' || nowChar == ')')
            { /*如果是运算符，就要准备入栈了*/
                if (sum.size() != 0)
                {    /*入栈之前要先将存储在sum里的数据输出出来*/
                    summation();
                }

                if (nowChar != ')' && (stack.empty() || map.get(nowChar) > map.get(stack.peek()) || stack.peek() == '('))
                {    /*入栈*/
                    stack.push(nowChar);
                } else {
                    while (!stack.isEmpty() && nowChar >= map.get(stack.peek()))
                    {  /*当栈不为空并且当前运算符的优先级不小于栈顶运算符时*/
                        if (stack.peek() == '(' || stack.peek() == ')')
                        {   /*对于括号运行符不需要进行输出*/
                            stack.pop();
                            break;
                        }

                        charMap.put(flag++, stack.pop());
                    }

                    if (nowChar != ')')
                    {       /*将当前运算符入栈，如果是右括号的话就不用入栈了，因为当遇到右括号是，栈里面必然有左括号，所以右括号要随着左括号一起丢掉*/
                        stack.push(nowChar);
                    }
                }
                continue;
            }
            else
                {    /*当不是运算符时，就进行数字的处理*/
                    int num = Integer.valueOf(nowChar) - 48;    /*Integer.valueOf(nowChar)输出的是字符的ASCII码值，要将它转化为实际数字*/
                    if(num<0||num>9)
                    {
                        String message = "There are illegal characters in it";
                        throw new ArithmeticHandleException(message);
                    }
                    else
                    {
                        sum.add(num);   /*可能不是一位数，所以可以先将该数字存储起来*/
                    }
                }
        }

        if (sum.size() != 0)
        {  /*此时sum里面可能还会有存储起来的数字，但还没输出，此时要进行输出了*/
            for (int j = 0; j < sum.size(); j++)
            {
                summation();
            }
        }

        while (!stack.isEmpty())
        {  /*和上面的原因一样*/
            charMap.put(flag++, stack.pop());
        }
    }

    /*将数组中的数字求和*/
    private void summation()
    {
        int pow = 0;
        for (int j = sum.size() - 1; j >= 0; j--)
        {
            add = (int) (add + sum.get(j) * Math.pow(10, pow++));   /*求幂运算*/
        }
        sum.clear();    /*清除ArrayList集合*/
        intMap.put(flag++, add);
        add = 0;    /*归零，不然下次会接着累加*/
    }

    public int operation() throws ArithmeticHandleException
    {
        Stack<Integer> stack = new Stack<>();   /*用于存放数据*/

        Arithmetic arithmetic = this;
        arithmetic.analyze(this.arithmetic);
        for (int i = 0; i < arithmetic.intMap.size() + arithmetic.charMap.size(); i++)
        {    /*遍历两个集合*/
            if (arithmetic.intMap.get(i) == null)
            {
                switch (arithmetic.charMap.get(i))
                {
                    case '-':   /*因为是减号，所以要考虑顺序*/
                        int one = stack.pop();
                        int two = stack.pop();
                        stack.push(two - one);
                        break;
                    case '+':
                        stack.push(stack.pop() + stack.pop());
                        break;
                    case '*':
                        stack.push(stack.pop() * stack.pop());
                        break;
                    case '/':   /*同减号，是因为顺序*/
                        int first = stack.pop();
                        int second = stack.pop();
                        stack.push(second / first);
                        break;
                }
            }
            else
                {
                stack.push(arithmetic.intMap.get(i));
                }
        }
        return stack.pop();
    }

}

异常处理：ArithmeticHandleException:

package arithmetic;

public class ArithmeticHandleException extends Exception {
    ArithmeticHandleException (String message)
    {
        super(message);
    }
}

主函数运行：

import arithmetic.Arithmetic;
import arithmetic.ArithmeticHandleException;

import java.util.Scanner;

public class MainClass {
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.next();
        Arithmetic arithmetic = new Arithmetic(string);
        try
        {
            System.out.print(arithmetic.operation());
        }
        catch (ArithmeticHandleException AE)
        {
            AE.printStackTrace();
        }
    }

}

目前处在调试阶段，还有很多东西需要改进。