java String实现加，减，乘，除运算。

       最近关心了一下java 字符串实现四则运算。在网上也找到一些前辈的资料，特此将自己写的代码记录下来。代码参考了a43350860（http://topic.csdn.net/u/20090302/17/ab16150e-137e-4b5a-9dcd-a95ef6cce19d.html）的发帖，当然bao110908 提的使用java6调用bshell脚本也是一种实现凡是。在这主要记录一下整个流程的思考过程，而不希望仅仅是copy一段代码实现。

    对于4则运算，我个人分析过程如下：

 4则运算的几种情况：带有括号（不考虑大，小，中括号，统称括号），例如3*（2-1）；带负数，例如3+（-2），其他正常的情况。

4则运算符优先级考虑，这个很明显，先“*”，“/”，再"+","-"最后是括号。

 基于以上分析，我个人将字符串进行切分，将带有括号的字符串切分为不带括号的字符串。具体思路是将括号里面的数据计算，然后用计算的记过取代整个括号，暂时忽略掉不带括号字符的计算过程。

例如 3+（1-2） ===3+-1    //暂不考虑两个符号紧挨 与个人常识上的差异。

    这样，最后得出的数据也是一个不带括号的字符串，就已经将带字符的字符串进行了完整的转换，现在的重点就再计算不带括号的字符身上了。

计算不带字符串的计算，我采用了2个栈来存放，一个栈存放符号，另一个存放数字，当存放符号时发现，当前的符号比栈顶得符号优先级低或者相等，就讲栈中的数据进行计算。例如 a+b-c，按照正常顺序，存放“-”是，数字栈中存放有a.b,而符号栈中存放有“+”，此时，进行判断，发现“+”与“-”优先级相等，于是计算 a +b的值（假设a+b=d）.计算后数字栈中将存放d,而符号栈将只存放"-".以此类推。

基于以上思想可用实现基本的4则运算，但有一个缺陷就是带负数的情况，例如 a  +  -2（真实数据可能是a+(-2)，但是在去除括号后就会导致这样的数据出现）,此时就会出错，因此实现是需判断，两个符号紧挨在以前的情况。另外还有第一个数字为负数的情况，例如: -1+2，这种情况也需要判断数字栈是否为空，如果为空，就蒋它放入数字当中而不是放入符号栈中。

代码如下，欢迎测试，如有问题请指出，谢谢

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

/**
 * 功能描述 . 只计算不带括号的加，减，乘，除
 *
 * @version 1.0
 * @data:2012-4-18 下午06:53:39
 * @author Administrator
 */
public class StringCaculate {

    private Stack numbers = new Stack();

    private Stack chs = new Stack();

    /**
     * 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
     *
     * @param str
     *            需要进行比较的字符
     * @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
     */
    private boolean compare(char str) {
        if (chs.empty()) {
            // 当为空时，显然 当前优先级最低，返回高
            return true;
        }
        char last = (char) chs.lastElement();
        switch (str) {
        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 BigDecimal caculate(String st) {
        StringBuffer sb = new StringBuffer(st);
        StringBuffer num = new StringBuffer();
        String tem = null;
        char next;
        while (sb.length() > 0) {
            tem = sb.substring(0, 1);// 获取字符串的第一个字符
            sb.delete(0, 1);
            if (isNum(tem.trim())) {
                num.append(tem);// 如果是数字，将其放入num当中
            } else {

                if (num.length() > 0 && !"".equals(num.toString().trim())) {// 当截取的字符不是数字时，则认为num中放置的时一个完整的数字，
                    // 如123+1,当获取到+时，前面的123可以认为是一个完整的数
                    BigDecimal bd = new BigDecimal(num.toString().trim());
                    numbers.push(bd);
                    num.delete(0, num.length());
                }
                // 如果chs为空，这认为这时第一个字符直接放入
                if (!chs.isEmpty()) {
                    // 当当前的运算符优先级等于或者小于栈顶得预算符时，做运算.
                    // 例如,1+2+3,当截取到2,3之间的“+”与1,2之间的"+"优先级相等时，可以先计算1+2，使其变成3+3
                    // 同样，1*2+3,当截取到2,3之间的“+”与1,2之间的"*"优先级小，可以先计算1*2，使其变成2+3

                    while (!compare(tem.charAt(0))) {
                        caculate();
                    }
                }
                // 当数字栈也为空时,既运算式的第一个数字为负数时
                if (numbers.isEmpty()) {
                    num.append(tem);
                } else {
                    chs.push(new Character(tem.charAt(0)));
                }
                // 判断后一个字符是否为“-”号，为"-"号时，认为数字为负数
                // 例如 1*2*(-5)，因为此运算不计算()，因此将被改写为1*2*-5,如此情况，须将"-"认为是负数表达式而非减号
                next = sb.charAt(0);
                if (next == '-') {
                    num.append(next);
                    sb.delete(0, 1);
                }

            }
        }
        // 由于前面将数字放入栈时，是通过获取符号为时处理，导致最后一个数字没有放入栈中，因此将最后的数字放入栈中
        BigDecimal bd = new BigDecimal(num.toString().trim());
        numbers.push(bd);
        // 此时符号栈上最多只有2个符号，并且栈顶得符号优先级高，做运算
        while (!chs.isEmpty()) {
            caculate();
        }
        return numbers.pop();
    }

    private void caculate() {
        BigDecimal b = numbers.pop();// 第二个运算数
        BigDecimal a = null;// 第一个运算数
        a = numbers.pop();
        char ope = chs.pop();
        BigDecimal result = null;// 运算结果
        switch (ope) {
        // 如果是加号或者减号，则
        case '+':
            result = a.add(b);
            // 将操作结果放入操作数栈
            numbers.push(result);
            break;
        case '-':
            // 将操作结果放入操作数栈
            result = a.subtract(b);
            numbers.push(result);
            break;
        case '*':
            result = a.multiply(b);
            // 将操作结果放入操作数栈
            numbers.push(result);
            break;
        case '/':
            result = a.divide(b);// 将操作结果放入操作数栈
            numbers.push(result);
            break;
        }
    }

    private boolean isNum(String num) {
        return num.matches("[0-9]");
    }

    /**
     *
     * 功能描述。
     * 解析，将带有括号的运算符变成没有带括号的字运算
     */
        public BigDecimal parse(String st) {
            int start = 0;
            StringBuffer    sts = new StringBuffer(st);
            int end = -1;
            while ((end = sts.indexOf(")")) > 0) {
                String s = sts.substring(start, end + 1);
                int first = s.lastIndexOf("(");
                BigDecimal value = caculate(sts.substring(first + 1, end));
                sts.replace(first, end + 1, value.toString());
            }
            return caculate(sts.toString());
        }

    public static void main(String[] args) {
        String a = "(5+-2)*1";
        StringCaculate caculate = new StringCaculate();
        System.out.println(caculate.parse(a));
    }
}