关于java中通过逆波兰式实现不带括号的四则运算，求教
- Java code
import 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<Character> s1=new Stack<Character>(); Stack<Object> s2=new Stack<Object>(); int len=expression.length(); //System.out.println(len); char c1; for(int i=0;i<len;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<Object> ob) { //存放后序的栈 Stack<Object> s3=new Stack<Object>(); //计算结果的栈 Stack<Double> s4=new Stack<Double>(); 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; } }}
一直有错，请帮忙看看
[解决办法]
以下红色的地方我改过。
import 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();
System.out.println(ex.getExpression(s));
}else{
System.out.println("表达式输入有误！");
}
}
//把算数表达式转化为后缀式（逆波兰式）
private String getExpression(String expression){
//存放操作符的栈
Stack<Character> s1=new Stack<Character>();
Stack<Object> s2=new Stack<Object>();
int len=expression.length();
//System.out.println(len);
char c1;
for(int i=0;i<len;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<Object> ob) {
//存放后序的栈
Stack<Object> s3=new Stack<Object>();
//计算结果的栈
Stack<Double> s4=new Stack<Double>();
while(!ob.isEmpty()){
s3.push(ob.pop());
}
while(!s3.isEmpty()){
if(!isOperator(s3.peek())){
s4.push((Double.parseDouble(((Character)s3.pop()).toString())));
}
else{
s4.push(cout(s4.pop(),s4.pop(),(Character)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=(Character)o;
//System.out.println("isO:"+c1);
if(c1=='+'||c1=='-'||c1=='*'||c1=='/'){
//System.out.println("yes");
return true;
}
else{
//System.out.println("no");
return false;
}
}
}