java中实现四则运算代码

代码的思路是通过正则判断计算每个最小的计算单元。以下是代码：

import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 计算器工具类
 * @author shuqi
 * @date  2015-7-23
 * @version since 1.0
 */
public class CalculatorUtil {

  public static BigDecimal arithmetic(String exp){
    if(!exp.matches("\\d+")){
      String result = parseExp(exp).replaceAll("[\\[\\]]", "");
      return new BigDecimal(result);
    }else{
      return new BigDecimal(exp);
    }
  }
  /**
   * 最小计数单位
   *
   */
  private static String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
  /**
   * 不带括号的运算
   */
  private static String noParentheses="^[^\\(\\)]+$";
  /**
   * 匹配乘法或者除法
   */
  private static String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
  /**
   * 匹配加法和减法
   */
  private static String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
  /**
   * 匹配只带一个括号的
   */
  private static String minParentheses="\\([^\\(\\)]+\\)";

  /**
   * 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3
   * @param expression
   * @return
   */
  private static String parseExp(String expression){
    //方法进入 先替换空格，在去除运算两边的()号
    expression=expression.replaceAll("\\s+", "").replaceAll("^\\(([^\\(\\)]+)\\)$", "$1");

    //最小表达式计算
    if(expression.matches(minExp)){
      String result=calculate(expression);
      return Double.parseDouble(result)>=0?result:"["+result+"]";
    }
    //计算不带括号的四则运算
    if(expression.matches(noParentheses)){
      Pattern patt=Pattern.compile(priorOperatorExp);
      Matcher mat=patt.matcher(expression);
      if(mat.find()){
        String tempMinExp=mat.group();
        expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
      }else{
        patt=Pattern.compile(operatorExp);
        mat=patt.matcher(expression);

        if(mat.find()){
          String tempMinExp=mat.group();
          expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));
        }
      }
      return parseExp(expression);
    }

    //计算带括号的四则运算
    Pattern patt=Pattern.compile(minParentheses);
    Matcher mat=patt.matcher(expression);
    if(mat.find()){
      String tempMinExp=mat.group();
      expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));
    }
    return parseExp(expression);
  }
  /**
   * 计算最小单位四则运算表达式（两个数字）
   * @param exp
   * @return
   */
  private static String calculate(String exp){
    exp=exp.replaceAll("[\\[\\]]", "");
    String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
    BigDecimal number1=new BigDecimal(number[0]);
    BigDecimal number2=new BigDecimal(number[1]);
    BigDecimal result=null;

    String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
    if("+".equals(operator)){
      result=number1.add(number2);
    }else if("-".equals(operator)){
      result=number1.subtract(number2);
    }else if("*".equals(operator)){
      result=number1.multiply(number2);
    }else if("/".equals(operator)){
      //第二个参数为精度，第三个为四色五入的模式
      result=number1.divide(number2,5,BigDecimal.ROUND_CEILING);
    }

    return result!=null?result.toString():null;
  }

}

代码原本是一个博客，原来代码没有注释而且存在BUG，我稍微修稿了一哈添加了注释。在这里做个笔记，方便以后用

另为表示对原作者的敬意，附上原始代码

/**
 * 四则运算表达式计算
 * @author penli
 *
 */
public class Arithmetic {
 public static void main(String args[]){
 System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2"));
 }
 public static double arithmetic(String exp){
 String result = parseExp(exp).replaceAll("[\\[\\]]", "");
 return Double.parseDouble(result);
 }
 /**
 * 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3
 * @param expression
 * @return
 */
 public static String parseExp(String expression){
 //String numberReg="^((?!0)\\d+(\\.\\d+(?<!0))?)|(0\\.\\d+(?<!0))$";
 expression=expression.replaceAll("\\s+", "").replaceAll("^\\((.+)\\)$", "$1");
 String checkExp="\\d";
 String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
 //最小表达式计算
 if(expression.matches(minExp)){
  String result=calculate(expression);

  return Double.parseDouble(result)>=0?result:"["+result+"]";
 }
 //计算不带括号的四则运算
 String noParentheses="^[^\\(\\)]+$";
 String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
 String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
 if(expression.matches(noParentheses)){
  Pattern patt=Pattern.compile(priorOperatorExp);
  Matcher mat=patt.matcher(expression);
  if(mat.find()){
  String tempMinExp=mat.group();
  expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
  }else{
  patt=Pattern.compile(operatorExp);
  mat=patt.matcher(expression);

  if(mat.find()){
   String tempMinExp=mat.group();
   expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));
  }
  }
  return parseExp(expression);
 }
 //计算带括号的四则运算
 String minParentheses="\\([^\\(\\)]+\\)";
 Pattern patt=Pattern.compile(minParentheses);
 Matcher mat=patt.matcher(expression);
 if(mat.find()){
  String tempMinExp=mat.group();
  expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));
 }
 return parseExp(expression);
 }
 /**
 * 计算最小单位四则运算表达式（两个数字）
 * @param exp
 * @return
 */
 public static String calculate(String exp){
 exp=exp.replaceAll("[\\[\\]]", "");
 String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
 BigDecimal number1=new BigDecimal(number[0]);
 BigDecimal number2=new BigDecimal(number[1]);
 BigDecimal result=null;

 String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
 if("+".equals(operator)){
  result=number1.add(number2);
 }else if("-".equals(operator)){
  result=number1.subtract(number2);
 }else if("*".equals(operator)){
  result=number1.multiply(number2);
 }else if("/".equals(operator)){
  result=number1.divide(number2);
 }

 return result!=null?result.toString():null;
 }
}

最后给大家分享一个网友的实现方法，个人感觉也很不错

import java.util.Stack;
/**
 * 利用栈，进行四则运算的类
 * 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack
 *
 * 基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；
 * 若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
 * 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级'(' > '*' = '/' > '+' = '-' > ')'
 *
 */
public class Operate {
  private Stack<Character> priStack = new Stack<Character>();// 操作符栈
  private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈   

  /**
   * 传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)
   * @param str 需要进行技术的表达式
   * @return 计算结果
   */
  public int caculate(String str) {
    // 1.判断string当中有没有非法字符
    String temp;// 用来临时存放读取的字符
    // 2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成
    StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时)
    StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率   

    while (string.length() != 0) {
      temp = string.substring(0, 1);
      string.delete(0, 1);
      // 判断temp，当temp为操作符时
      if (!isNum(temp)) {
        // 1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum
        if (!"".equals(tempNum.toString())) {
          // 当表达式的第一个符号为括号
          int num = Integer.parseInt(tempNum.toString());
          numStack.push(num);
          tempNum.delete(0, tempNum.length());
        }
        // 用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
        // 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。   

        // 判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)
        while (!compare(temp.charAt(0)) && (!priStack.empty())) {
          int a = (int) numStack.pop();// 第二个运算数
          int b = (int) numStack.pop();// 第一个运算数
          char ope = priStack.pop();
          int result = 0;// 运算结果
          switch (ope) {
          // 如果是加号或者减号，则
          case '+':
            result = b + a;
            // 将操作结果放入操作数栈
            numStack.push(result);
            break;
          case '-':
            result = b - a;
            // 将操作结果放入操作数栈
            numStack.push(result);
            break;
          case '*':
            result = b * a;
            // 将操作结果放入操作数栈
            numStack.push(result);
            break;
          case '/':
            result = b / a;// 将操作结果放入操作数栈
            numStack.push(result);
            break;
          }   

        }
        // 判断当前运算符与栈顶元素优先级， 如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈
        if (temp.charAt(0) != '#') {
          priStack.push(new Character(temp.charAt(0)));
          if (temp.charAt(0) == ')') {// 当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括号
            priStack.pop();
            priStack.pop();
          }
        }
      } else
        // 当为非操作符时（数字）
        tempNum = tempNum.append(temp);// 将读到的这一位数接到以读出的数后(当不是个位数的时候)
    }
    return numStack.pop();
  }   

  /**
   * 判断传入的字符是不是0-9的数字
   *
   * @param str
   *      传入的字符串
   * @return
   */
  private boolean isNum(String temp) {
    return temp.matches("[0-9]");
  }   

  /**
   * 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
   *
   * @param str 需要进行比较的字符
   * @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
   */
  private boolean compare(char str) {
    if (priStack.empty()) {
      // 当为空时，显然 当前优先级最低，返回高
      return true;
    }
    char last = (char) priStack.lastElement();
    // 如果栈顶为'('显然，优先级最低，')'不可能为栈顶。
    if (last == '(') {
      return true;
    }
    switch (str) {
    case '#':
      return false;// 结束符
    case '(':
      // '('优先级最高,显然返回true
      return true;
    case ')':
      // ')'优先级最低，
      return false;
    case '*': {
      // '*/'优先级只比'+-'高
      if (last == '+' || last == '-')
        return true;
      else
        return false;
    }
    case '/': {
      if (last == '+' || last == '-')
        return true;
      else
        return false;
    }
      // '+-'为最低，一直返回false
    case '+':
      return false;
    case '-':
      return false;
    }
    return true;
  }   

  public static void main(String args[]) {
    Operate operate = new Operate();
    int t = operate.caculate("(3+4*(4*10-10/2)#");
    System.out.println(t);
  }   

}