java计算器的核心算法
oneday做了计算器的界面，网上搜了下算法，但是搜不到具体的java代码，闲来无事，写了个，欢迎大家来喷！
* @author superGenius吴大仙＾＾！蛋疼仔
* 计算器算法的实现
*定义两个堆栈，一个放置操作数，一个放置操作符
*1.首先把得到的数学表达式转化成为逆波兰式 Reverse Polish Notation
* 对于一个表达式，遇到数字便+入到新的逆波兰式，假如遇到的是操作符，首先比较其和操作符堆栈里面
* 操作符的优先级，假如优先级较高，便加入到操作符堆栈中，or+入到逆波兰式中
* 2.计算逆波兰式
* 遍历波兰式，遇到数字便放入堆栈，遇到操作符，操作数堆栈弹出，执行相应的操作符操作，util...then ok;

import java.util.HashMap;import java.util.Map;import java.util.Stack;public class CalculatorIn {    private Stack<Double> operandStack=new Stack<Double>();//操作数堆栈    private Stack<String> operatorStack=new Stack<String>();//操作符堆栈    private String expression;//算数表达式    private double result=0.0;//计算结果    private Map<String,Integer> priorityMap=new HashMap<String,Integer>();//用于存储操作符优先级的Map    //初始化优先级约定(可根据计算的复杂程度扩展)    public CalculatorIn()    {        priorityMap.put("+",0);        priorityMap.put("-",0);        priorityMap.put("*", 1);        priorityMap.put("/", 1);           }       public int getPriority(String op)//得到一个操作符的优先级    {        return priorityMap.get(op);    }       public boolean highPriority(String op)//判断操作符的优先级在堆栈里面是否最为高    {        int opPri=getPriority(op);//当前操作符的优先级        if(!operatorStack.empty())        {        for(String s:operatorStack)        {            int priority=getPriority(s);            if(opPri<priority)                return false;                   }        }        return true;    }    //把表达式转化成逆波兰式    public String expToIpn()    {        int index=0;        int end=0;        String Ipn="";        for(int i=0;i<expression.length();i++)        {            String temps=String.valueOf(expression.charAt(i));            if(temps.matches("[0-9.]"))//检查是否是数字            {                end++;            }            else            {                String tempOperand=expression.substring(index,end);//得到操作数                Ipn+=tempOperand+",";                String tempOperator=expression.substring(end,++end);//得到操作符                if(tempOperator.equals("!"))//假如到表达式的最后将操作符 全部弹出                    {                    while(!operatorStack.empty())                    {                         Ipn+=operatorStack.pop()+",";                     }                    }                 else                 {                if(highPriority(tempOperator))//优先级高的压入操作符堆栈                    {                    operatorStack.push(tempOperator);                    }                 else                    {                     while(!operatorStack.empty())//                    {                         Ipn+=operatorStack.pop()+",";                     }                                         operatorStack.push(tempOperator);                    }                //System.out.println(tempOperand+","+tempOperator);                index=end;            }            }                   }        return Ipn;       }    public double calculateIpn(String[] Ipn)//计算逆波兰式    {                 for(int i=0;i<Ipn.length;i++)        {        //    System.out.println(Ipn[i]);            if(Ipn[i].matches("^[0-9]+.?[0-9]*$"))//正则表达式判断是数字            {                operandStack.push(Double.parseDouble(Ipn[i]));            }                else                {                    popOperand(Ipn[i]);                }        }        return result;           }    //遇到操作符时，弹出操作数，进行相应操作，并保村result    public void popOperand(String operator)    {        double d1=operandStack.pop();        double d2=operandStack.pop();        System.out.println(d1+operator+d2);        if(operator.equals("+"))            result=d2+d1;        if(operator.equals("-"))            result=d2-d1;        if(operator.equals("*"))            result=d2*d1;        if(operator.equals("/"))            result=d2/d1;//System.out.println(result);            operandStack.push(result);           }    public Stack getOperandStack() {        return operandStack;    }    public void setOperandStack(Stack operandStack) {        this.operandStack = operandStack;    }    public Stack getOperatorStack() {        return operatorStack;    }    public void setOperatorStack(Stack operatorStack) {        this.operatorStack = operatorStack;    }    public String getexpression_r() {        return expression;    }    public void setexpression_r(String expression) {        this.expression = expression;    }    public double getResult() {        return result;    }    public void setResult(double result) {        this.result = result;    }    public static void main(String[] args)    {        CalculatorIn cal=new CalculatorIn();        String exp="32+1*2*2/2*2-2/2!";        cal.setexpression_r(exp);        String[] Ipn=cal.expToIpn().split(",");         for(int i=0;i<Ipn.length;i++)        System.out.println(Ipn[i]);        System.out.println(cal.calculateIpn(Ipn));    }