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)); }