JAVA实现字符串四则运算

一.问题描述：

由于JAVA作业要做一个计算器，然后计算器前端输出的是一个不带括号的四则表达式字符串。像“9.0*56-23/4747+8*7=”这样，然后我要把输出的结果返回给它。

二.思路：

1.首先想到有优先级，先算乘除后算加减。可以用中缀表达式转后缀表达式进行计算。但是我想不到怎么用中缀表达式构造二叉树，只要构造完了后序遍历一下就出结果了。此方法卒。

2.想以前学过逆波兰表达式好像用栈可以计算出这种表达式的值。

以前的博客：

后缀表达式求值：http://blog.csdn.net/h992109898/article/details/50636108

中缀表达式转后缀表达式：http://blog.csdn.net/h992109898/article/details/50636275

尴尬，好像用上面2篇博客就可以完美解决这个问题了。

不过说一说现在的思路：

维护一个栈：扫描字符串

（1）遇到数字入栈（包括小数点）

（2）遇到+号或者-号，检查前面是否有*号或者/号。再检查前面是否有+号或者-号。

弹栈直到遇到前面相应的符号，保存表达式右边结果。弹掉符号，再弹栈遇到下一个符号或者栈空。进行对应操作。

（3）遇到*号或者/号，检查前面是否有*号或者/号。

弹栈直到遇到前面相应的符号，保存表达式右边结果。弹掉符号，再弹栈遇到下一个符号或者栈空。进行对应操作。

说明：在（2）中先检测*号或者/号，保证了栈中加号之前一定不会有*号或者/号，因为如果加号之前存在*号或者/号，此时的+号会进行弹栈。因此（3）中无需检测+号或者-号。并且栈中不会存在多于2个+号或者-号。

三.代码：

import java.util.Stack;

public class ExpressionToDouble {
private static boolean isNumber(char ch){
return ch == '.' || (ch >= '0' && ch <= '9');
}

private static void hasAddOrSub(Stack<Character> s, char opration){
StringBuilder number = new StringBuilder();
while(true){
char cur = s.peek();
if (cur == opration)
break;

number.insert(0, cur);
s.pop();
}

s.pop();
double right = Double.parseDouble(number.toString());
number.replace(0, number.length(), "");

while(!s.isEmpty()){
char cur = (char)s.peek();
number.insert(0, cur);
s.pop();
}

double left = Double.parseDouble(number.toString());
number.replace(0, number.length(), "");

double res = 0;
if (opration == '+')
res = left + right;
else
res = left -right;
String str = res + "";
for(char chr : str.toCharArray()){
s.push(chr);
}
}

private static void hasMulOrDiv(Stack<Character> s, char opration){
StringBuilder number = new StringBuilder();
while(true){
char cur = s.peek();
if (cur == opration)
break;

number.insert(0, cur);
s.pop();
}

s.pop();
double right = Double.parseDouble(number.toString());
number.replace(0, number.length(), "");

while(!s.isEmpty()){
char cur = s.peek();
if (cur == '+' || cur == '-')
break;
number.insert(0, cur);
s.pop();
}

double left = Double.parseDouble(number.toString());
number.replace(0, number.length(), "");
double res = 0;
if (opration == '*')
res = left * right;
else
res = left / right;

String str = res + "";
for(char chr : str.toCharArray()){
s.push(chr);
}
}

private static boolean checkInfo(char []datas){
for(int i = 0; i < datas.length-1; i++){
if (!isNumber(datas[i]) && !isNumber(datas[i+1]))
return false;
if (datas[i] == '.' && datas[i+1] == '.')
return false;
}
return true;
}

public static String StringToRes(String info){
Stack<Character> s = new Stack<Character>();
char []datas = info.toCharArray();
if (!checkInfo(datas))
return "";
boolean hasAdd = false;
boolean hasSub = false;
boolean hasMul = false;
boolean hasDiv = false;

for (char ch : datas){
if (isNumber(ch)){
s.push(ch);
}
else{
switch(ch){
case '+':
if (hasMul){
hasMulOrDiv(s, '*');
hasMul = false;
}

if (hasDiv){
hasMulOrDiv(s, '/');
hasDiv = false;
}

if (hasAdd){
hasAddOrSub(s, '+');
hasAdd = false;
}

if (hasSub){
hasAddOrSub(s, '-');
hasSub = false;
}

s.push(ch);
hasAdd = true;
break;
case '-':
if (hasMul){
hasMulOrDiv(s, '*');
hasMul = false;
}

if (hasDiv){
hasMulOrDiv(s, '/');
hasDiv = false;
}

if (hasAdd){
hasAddOrSub(s, '+');
hasAdd = false;
}

if (hasSub){
hasAddOrSub(s, '-');
hasSub = false;
}

s.push(ch);
hasSub = true;
break;
case '*':
if (hasMul){
hasMulOrDiv(s, '*');
hasMul = false;
}

if (hasDiv){
hasMulOrDiv(s, '/');
hasDiv = false;
}
s.push(ch);
hasMul = true;
break;
case '/':
if (hasMul){
hasMulOrDiv(s, '*');
hasMul = false;
}

if (hasDiv){
hasMulOrDiv(s, '/');
hasDiv = false;
}
s.push(ch);
hasDiv = true;
break;
case '=':
if (hasMul){
hasMulOrDiv(s, '*');
hasMul = false;
}

if (hasDiv){
hasMulOrDiv(s, '/');
hasDiv = false;
}

if (
aa83
hasAdd){
hasAddOrSub(s, '+');
hasAdd = false;
}

if (hasSub){
hasAddOrSub(s, '-');
hasSub = false;
}

StringBuilder number = new StringBuilder();
while(!s.isEmpty()){
char cur = (char)s.peek();
number.insert(0, cur);
s.pop();
}
return number.toString();

}
}
}
return "";
}

public static void main(String[] args) {
System.out.println(StringToRes("78.54-24.34*54+24/23="));
}

}