java 波兰式,关于java中通过逆波兰式实现不带括号的四则运算，求教解决方法

Java codeimport java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.Stack;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Expression{

public static void main(String args[]){

//得到输入的算数表达式

String s=new String();

System.out.println("输入算数表达式：");

BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));

try {

s=bf.readLine();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//通过正则表达式判断输入的是否正确

Pattern p=Pattern.compile("([1-9][0-9]*[+\\-\\*/])+[1-9][0-9]*");

Matcher m=p.matcher(s);

if((m.matches()==true)){

Expression ex=new Expression();

ex.getExpression(s);

}else{

System.out.println("表达式输入有误！");

}

}

//把算数表达式转化为后缀式(逆波兰式)

private String getExpression(String expression){

//存放操作符的栈

Stack s1=new Stack();

Stack s2=new Stack();

int len=expression.length();

//System.out.println(len);

char c1;

for(int i=0;i

c1=expression.charAt(i);

//s1.push('#');

System.out.println(c1);

if(isOperator(c1)==true){

//System.out.println(c1);

//操作数为操作符且优先级比s1栈顶操作符优先级高时，直接把操作符压入s1

if(s1.empty()){

s1.push(c1);

//System.out.println(c1);

}

else {

if(priorityCompare(c1,s1.peek())==1){

s1.push(c1);

//System.out.println(s1.peek());

}

else{

//弹出s1栈顶的操作符并压入s2，直到c1优先级小于s1栈顶的操作符优先级

while(priorityCompare(c1,s1.peek())!=1){

s2.push(s1.pop());

System.out.println(s2.peek());

}

s1.push(c1);

//System.out.println(s1.peek());

}

}

}else{

//若操作数为数字，直接压入s2中

s2.push(c1);

//System.out.println(c1);

}

}

//把s1中剩余的元素压入s2中

while(!s1.isEmpty()){

s2.push(s1.pop());

//System.out.println(s1.peek());

}

return count_result(s2);

}

//根据后序的计算出结果

private String count_result(Stack ob) {

//存放后序的栈

Stack s3=new Stack();

//计算结果的栈

Stack s4=new Stack();

while(!ob.isEmpty()){

s3.push(ob.pop());

}

while(!s3.isEmpty()){

if(!isOperator(s3.peek())){

s4.push((Double)(s3.pop()));

}

else{

s4.push(cout(s4.pop(),s4.pop(),(char)s3.pop()));

}

}

return Double.toString(s4.peek());

}

private Double cout(double x, double y, char z) {

double result=0;

switch(z){

case '+':

result=x+y;

break;

case '-':

result=x-y;

break;

case '*':

result=x*y;

break;

case '/':

result=x/y;

break;

}

//System.out.println(result);

return result;

}

//比较两个操作符的优先级

private int priorityCompare(char c1, char c2) {

switch(c1){

case '+':

case '-':

return(c2=='*'||c2=='/'?-1:0);

case '*':

case '/':

return(c2=='+'||c2=='-'?1:0);

}

return 1;

//return getPriority(c1) - getPriority(c2);

}

/*int getPriority(char c) {

if(c == '+' || c == '-')

return 1;

else

return 2;

}*/

//检测是否是操作符

private boolean isOperator(Object o){

//System.out.println("isO:"+o);

char c1=(char)o;

//System.out.println("isO:"+c1);

if(c1=='+'||c1=='-'||c1=='*'||c1=='/'){

//System.out.println("yes");

return true;

}

else{

//System.out.println("no");

return false;

}

}

}