转化字符串表达式为数学公式并算出结果

 

/*
 * FormulaCalculator.java
 *
 * Created on 2007年9月18日, 上午11:40
 * @title 转化字符串表达式为数学公式并算出结果
 * @description 转化字符串表达式为数学公式并算出结果
 * 注意:为了区分负号，这边使用#代替减号
 * 使用方法:
 * FormulaCalculator calculator=new FormulaCalculator();
 * calculator.getResult("10.23#20.67*(5.12+7.82)/2",2);
 * v1.0.0 created by chenfc
 *
 */

package org.jceun;

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

public class FormulaCalculator ...{
    private  boolean isRightFormat = true;
    public  String DIVISOR_EQUALS_ZERO="0.0";//除数为零时的返回值
    /** *//**
     * 为了区分负号，这边使用#代替减号
     * @param formula 字符串表达式
     * @return 返回公式计算结果
     */
    public  double getResult(String formula)...{
        double returnValue = 0;
        try...{
            returnValue = doAnalysis(formula);
        }catch(NumberFormatException nfe)...{
            System.out.println("公式格式有误，请检查:" + formula);
        }catch(Exception e)...{
            e.printStackTrace();
        }
        if(!isRightFormat)...{
            System.out.println("公式格式有误，请检查:" + formula);
        }
        return returnValue;
    }
    /** *//**
     * 采用BigDecimal.ROUND_HALF_UP方式返回指定精度的运算结果
     * @param formula 公式
     * @param decimalPlace 要保留的小数位数
     * @return 返回公式计算结果
     */
    public  String getResult(String formula,int decimalPlace)...{
        return getResult(formula,decimalPlace,BigDecimal.ROUND_HALF_UP);
    }
    /** *//**
     * 返回指定精度及舍去尾数的策略的运算结果
     * @param formula 公式
     * @param decimalPlace 要保留的小数位数
     * @param roundMethod 舍去尾数的策略
     *          可取值有BigDecimal.ROUND_HALF_UP BigDecimal.ROUND_HALF_DOWN祥见BigDecimal
     * @return 返回公式计算结果
     */
    public  String getResult(String formula,int decimalPlace,int roundMethod)...{
        double result=getResult(formula);
        if(result==Double.MAX_VALUE)
            return DIVISOR_EQUALS_ZERO;
        else
            return numberAround(result,decimalPlace,roundMethod);
    }
    private  double doAnalysis(String formula)...{
        double returnValue = 0;
        LinkedList<Integer> stack = new LinkedList<Integer>();
        
        int curPos = 0;
        String beforePart = "";
        String afterPart = "";
        String calculator = "";
        isRightFormat = true;
        while(isRightFormat&&(formula.indexOf('(') >= 0||formula.indexOf(')') >= 0))...{
            curPos = 0;
            for(char s : formula.toCharArray())...{
                if(s == '(')...{
                    stack.add(curPos);
                }else if(s == ')')...{
                    if(stack.size() > 0)...{
                        beforePart = formula.substring(0, stack.getLast());
                        afterPart = formula.substring(curPos + 1);
                        calculator = formula.substring(stack.getLast() + 1, curPos);
                        formula = beforePart + doCalculation(calculator) + afterPart;
                        stack.clear();
                        break;
                    }else...{
                        System.out.println("有未关闭的右括号！");
                        isRightFormat = false;
                    }
                }
                curPos++;
            }
            if(stack.size() > 0)...{
                System.out.println("有未关闭的左括号！");
                break;
            }
        }
        if(isRightFormat)...{
            returnValue = doCalculation(formula);
        }
        return returnValue;
    }
    /** *//**
     * 为了区分负号，这边使用#代替减号
     */
    private  double doCalculation(String formula) ...{
        ArrayList<Double> values = new ArrayList<Double>();
        ArrayList<String> operators = new ArrayList<String>();
        int curPos = 0;
        int prePos = 0;
        for (char s : formula.toCharArray()) ...{
            if (s == '+' || s == '#' || s == '*' || s == '/') ...{
                values.add(Double.parseDouble(formula.substring(prePos, curPos)
                .trim()));
                operators.add("" + s);
                prePos = curPos + 1;
            }
            curPos++;
        }
        values.add(Double.parseDouble(formula.substring(prePos).trim()));
        char op;
        for (curPos = operators.size() - 1; curPos >= 0; curPos--) ...{
            op = operators.get(curPos).charAt(0);
            switch (op) ...{
                case '*':
                    values.add(curPos, values.get(curPos) * values.get(curPos + 1));
                    values.remove(curPos + 1);
                    values.remove(curPos + 1);
                    operators.remove(curPos);
                    break;
                case '/':
                    if(values.get(curPos + 1).doubleValue()==0.0)//除数为零时
                        values.add(curPos, new Double(getDefaultValue()));
                    else
                        values.add(curPos, values.get(curPos) / values.get(curPos + 1));
                    values.remove(curPos + 1);
                    values.remove(curPos + 1);
                    operators.remove(curPos);
                    break;
            }
        }
        for (curPos = operators.size() - 1; curPos >= 0; curPos--) ...{
            op = operators.get(curPos).charAt(0);
            switch (op) ...{
                case '+':
                    values.add(curPos, values.get(curPos) + values.get(curPos + 1));
                    values.remove(curPos + 1);
                    values.remove(curPos + 1);
                    operators.remove(curPos);
                    break;
                case '#':
                    values.add(curPos, values.get(curPos) - values.get(curPos + 1));
                    values.remove(curPos + 1);
                    values.remove(curPos + 1);
                    operators.remove(curPos);
                    break;
            }
        }
        return values.get(0).doubleValue();
    }
    /** *//**
     * 对数字进行四舍五入
     * @param dN 要四舍五入的数
     * @param decimalPlace 精度
     * @param roundMethod 舍去尾数的策略
     *          可取值有BigDecimal.ROUND_HALF_UP BigDecimal.ROUND_HALF_DOWN祥见BigDecimal
     */
    public  String numberAround(double dN,int decimalPlace, int roundMethod)...{
        BigDecimal bd = new BigDecimal(String.valueOf(dN));
        bd = bd.setScale(decimalPlace, roundMethod);
        return String.valueOf(bd);
    }
    /** *//**
     * 对给定的字符串进行模式匹配
     * @param str 要匹配的字符串
     * @param regix 模式
     * @return 返回匹配结果，成功为true,否则为false
     **/
    public  boolean check(String str,String regix)...{
        boolean result=false;
        Pattern p=Pattern.compile(regix);
        Matcher m =p.matcher(str);
        result=m.matches();
        return result;
    }
}