计算器1.0版 002

其实我是先写好了JAVA代码,然后才写的C代码

BoLan.java//实现中缀表达式的计算,使用逆波兰表达式实现

package com.laolang.math.bolan;

import java.util.Stack;

/**
 * 将中缀表达式转化为逆波兰表达式并计算
 * @version 1.1
 * @author laolang
 * 
 */
public class BoLan {

    /** 构造一个中缀表达式计算器
     * 此构造方法需要一个中棳表达式
     *
     * @param exp 中缀表达式String对象
     */
    public BoLan(String exp) {
        super();
        this.bolan = new StringBuffer();
        this.exp = exp;
        this.expStack = new Stack<Character>();
        this.expStack.push(new Character('#'));
        this.calStack = new Stack<Integer>();

    }

    /**
     * 计算表达式的值
     *
     * @return 计算结果
     */
    public int calculate() {
        this.toBoLan();
        char[] bolanArr = this.bolan.toString().toCharArray();

        for (char ch : bolanArr) {
            if ('0' <= ch && ch <= '9') {
                this.calStack.push(new Integer(ch-48));
            } else {
                    int a = calStack.pop().intValue();
                    int b = calStack.pop().intValue();
                    calStack.push( new Integer( cal(b,ch,a)));
            }
        }

        return calStack.peek().intValue();
    }

    /**
     * 两个数字计算
     *
     * @param a 操作数
     * @param o 运算符
     * @param b 操作数
     * @return 计算结果
     */
    private int cal(int a, char o, int b) {
        int res = 0;
        switch (o) {
        case '+': {
            res = a + b;
            break;
        }
        case '-': {
            res = a - b;
            break;
        }
        case '*': {
            res = a * b;
            break;
        }
        case '/': {
            res = a / b;
            break;
        }
        }
        return res;
    }

    /**
     * 将中缀表达式转化为后缀表达式
     */
    private void toBoLan() {
        char[] expArr = exp.toCharArray();
        for (char ch : expArr) {
            if (32 == ch) {
                continue;
            }
            if ('0' <= ch && ch <= '9') {
                this.bolan.append(ch);
            } else {
                int result = compareOperator(ch, expStack
                        .peek().charValue());
                if (result > 0) {
                    this.expStack.push(new Character(ch));
                } else {
                    while (compareOperator(ch, expStack
                            .peek().charValue()) <= 0) {
                        char c = expStack.pop()
                                .charValue();
                        this.bolan.append(c);
                    }
                    expStack.push(new Character(ch));
                }

            }

        }

        while ('#' != expStack.peek().charValue()) {
            char c = this.expStack.pop().charValue();
            this.bolan.append(c);
        }
        
        System.out.println(bolan.toString());
    }

    /**
     * 比较运算符的优先级
     *
     * @param a 运算符
     * @param b 运算符
     * @return 比较结果
     * 
     */
    private int compareOperator(char a, char b) {
        int result = 0;
        switch (a) {
        case '+':
        case '-': {
            if ('*' == b || '/' == b) {
                result = -1;
            }
            if ('#' == b) {
                result = 1;
            }
            break;
        }
        case '*':
        case '/': {
            if ('+' == b || '-' == b) {
                result = 1;
            }
            if ('#' == b) {
                result = 1;
            }
            break;
        }
        case '#': {
            return -1;
        }
        }
        return result;
    }


    /**
     * 设置表达式的值
     * 
     *
     * @param exp the new exp
     */
    public void setExp(String exp) {
        this.exp = exp;
    }


    /** 保存转化后的逆波兰表达式 */
    private StringBuffer bolan;

    /** 中缀表达式 */
    private String exp;

    /** 用于将中缀表达式转化为后缀表达式的栈 */
    private Stack<Character> expStack;

    /** 用于计算后缀表达式的栈 */
    private Stack<Integer> calStack;

}

HelloWorld.java//测试

package com.laolang.hello;

import com.laolang.math.bolan.BoLan;

public class HelloWorld {
    public static void main(String[] args) {
        String test = "1 + 2 * 3 - 7 * 5";
        String test1 = "1 + 2";
        int a = 1;
        int b = 2;
        char o = '*';
        BoLan bolan = new BoLan(test);
        System.out.println(bolan.calculate());

        double d = Double.parseDouble("4");
        double w = Double.parseDouble("35");
        System.out.println(d/w);
        
        System.out.println("Hello World!");
    }

}