Java计算器实现(逆波兰式)

package hfw.util;

import java.util.ArrayDeque; import java.util.Deque; /** *

*逆波兰式

*总结，java版的Eval：逆波兰和动态编译，推荐用动态编译，因为逆波兰式不认识\4\，只认识\ *@author zyh */

public class RNP { /**

* 运算数 */

private static Deque operationNum = new ArrayDeque(); /**

* 运算符 */

private static Deque operator = new ArrayDeque(); /**

* 将表达式转换为逆波兰式 * @param expression * @return */

private static void str2Rnp(String expression){ operationNum.clear(); operator.clear(); int index = 0; for(int i=0;i

//区分负号和减号,如果'-'前面的一个是+-*/( 认为是负号,'-'前面的是数或)if(c=='-'){ int in = i; while((expression.charAt(in-1)) ==' '){ in--; if(in==0){ break; }

认为是减号

} if(in==0){ continue; } String previous = expression.substring(in-1,i); if(isOperator(previous.charAt(0)) || previous.charAt(0)=='('){ continue; } }

if(operationNum.trim().length()>0){ RNP.operationNum.push(operationNum.trim()); }

index = i+1;

String operator = c+\

//如果操作符是'('，直接入栈 if('('==c){ RNP.operator.push(operator);

//如果操作符是')'，将'('操作符之后的全部出栈，入栈操作数，'(' ')'舍弃

}else if(')'==c){ while(true){ String o = RNP.operator.pollFirst(); if(o==null || \ break; } RNP.operationNum.push(o); } //如果操作符是+-*/ }else{ String o = RNP.operator.peekFirst(); if(o== null){//如果操作符栈为空，操作符直接入栈 RNP.operator.push(operator); }else { char operator2 = o.charAt(0); //比较操作符，和操作符栈首的大小，如果操作符大，直接入栈 if(operator2=='(' || operator2==')' || orderOperator(c,operator2)){ RNP.operator.push(operator); //如果操作符栈首大，将操作符栈小于操作符的全部出栈，入栈操作数，最后改操作符入栈 }else{ while(true){ if(o==null || o.charAt(0) =='('|| o.charAt(0) ==')'){ break; } if(orderOperator(c, o.charAt(0))){

break; } o = RNP.operator.pollFirst(); RNP.operationNum.push(o); o = RNP.operator.peekFirst(); } RNP.operator.push(operator); } } } } } String operationNum = expression.substring(index); if(operationNum.trim().length()>0){ RNP.operationNum.push(operationNum.trim()); } while(RNP.operator.size()>0){ RNP.operationNum.push(RNP.operator.pollFirst()); } // RNP.operationNum.addAll(RNP.operator); } //判断一个字符是否为运算符

private static boolean isOperator(char c) { return c=='+' || c=='-' || c=='*' || c=='/'; }

//判断运算符顺序，true表示运算符operator1>operator2,false表示相等或小于 private static boolean orderOperator(char operator1, char operator2){ if((operator1=='*' || operator1=='/') && (operator2=='+' || operator2=='-')){ return true; } return false; } /** * 计算逆波兰式的值 * @return */

private static double countRnp(){ while(RNP.operationNum.size()>0){ String s = RNP.operationNum.pollLast(); //如果是操作符，取出栈顶的两个操作数，直接运算 char operator = s.charAt(0); if(s.length()==1 && isOperator(operator)){ String a = RNP.operator.pollFirst(); String b = RNP.operator.pollFirst();

} /**

if('+'==operator){ double result = Double.parseDouble(b)+Double.parseDouble(a); RNP.operator.push(result+\}else if('-'==operator){ double result = Double.parseDouble(b)-Double.parseDouble(a); RNP.operator.push(result+\}if('*'==operator){ double result = Double.parseDouble(b)*Double.parseDouble(a); RNP.operator.push(result+\}if('/'==operator){ double result = Double.parseDouble(b)/Double.parseDouble(a); RNP.operator.push(result+\}

//如果是操作数，入栈 }else{ RNP.operator.push(s); } }

double result = Double.parseDouble(RNP.operator.pollLast()); return result;

* 计算逆波兰式的值(整数) * @return */

private static int intRnp(){ while(RNP.operationNum.size()>0){ String s = RNP.operationNum.pollLast(); //如果是操作符，取出栈顶的两个操作数，直接运算 char operator = s.charAt(0); if(s.length()==1 && isOperator(operator)){ String a = RNP.operator.pollFirst(); String b = RNP.operator.pollFirst(); if('+'==operator){ int result = Integer.parseInt(b)+Integer.parseInt(a); RNP.operator.push(result+\ }else if('-'==operator){ int result = Integer.parseInt(b)-Integer.parseInt(a); RNP.operator.push(result+\ }if('*'==operator){ int result = Integer.parseInt(b)*Integer.parseInt(a); RNP.operator.push(result+\ }if('/'==operator){ int result = Integer.parseInt(b)/Integer.parseInt(a);

RNP.operator.push(result+\ } //如果是操作数，入栈 }else{ RNP.operator.push(s); } } int result = Integer.parseInt(RNP.operator.pollLast()); return result; } /**

* 计算表达式的值 * @param expression * @return */

public static double calculate(String expression){ try{ str2Rnp(expression); return countRnp(); }catch(Exception e){ e.printStackTrace(); System.out.println(\请检查表达式\ return 0.0; } } /**

* 计算表达式的值(整数) * @param expression * @return */

public static int intCalculate(String expression){ try{ str2Rnp(expression); return intRnp(); }catch(Exception e){ e.printStackTrace(); System.out.println(\请检查表达式\ return 0; } }

public static void main(String[] args) { String s= \ System.out.println(RNP.calculate(s));

}

}

s = \ -2) * -4)-9*( -1 + 2)\System.out.println(RNP.intCalculate(s));

百度搜索“77cn”或“免费范文网”即可找到本站免费阅读全部范文。收藏本站方便下次阅读，免费范文网，提供经典小说综合文库Java计算器实现(逆波兰式)在线全文阅读。