比windows自带计算器还强的四则复杂运算计算器！
中缀表达式转后缀表达式并进行计算的计算器（支持带负号、括号和小数的加减乘除运算）
一步一步来
我们先要将这一字符串进行分析，哪些是数字，哪些是符号。（比如：-7.5就是数字）
具体代码如下：
// 表达式转中缀表达式(支持小数点，负数，小括号)
public List<String> getList(String expression) {
List<String> exp = new ArrayList<String>();//存放解析后的中缀表达式
String merge = "";
int index = 0;
char ch, ch1 = 0;
boolean flag = false;
expression = expression.replace(" ", "");
while (index != expression.length()) {
ch = expression.substring(index, index + 1).charAt(0);
merge += ch;
if (index < expression.length() - 1) {// 防止下标越界
ch1 = expression.substring(index + 1, index + 2).charAt(0);
if (isOper(ch1)) {
exp.add(merge);
merge = "";
flag = false;
} else if (isOper(ch)) {
if (flag == false && exp.size() > 0) {
exp.add(merge);
merge = "";
flag = false;
}
}
if (ch == '(' && ch1 == '-' || isOper(ch) && ch1 == '-')
flag = true;
}
index++;
}
exp.add(merge);
return exp;
}
接下来就是重头戏了！！！中缀表达式—>后缀表达式思路分析图：
遵循以上红字规则处理第二个左括号“（”后面的元素，直到右括号“）”
将符号栈中所有符号弹出加入到集合List中，直到碰到一个与右括号匹配的左括号
以上就是从中缀表达式转换到后缀表达式的图解！得：后缀表达式为：7.5 - 6 * 2 - 6.5 - 5.22 - - + /
下面是代码详解：
// 中缀表达式转后缀表达式(有个记录负号索引的全局变量minus，方便计算)
public List<String> toRPN(String expression) {
List<String> list=getList( expression );
List<String> rPN=new ArrayList<String>();// 用于存放后缀表达式
Stack<String> exp=new Stack<String>();// 用于操作判断符号
minus=new ArrayList<>();
for (String s : list) {// 将中缀表达式每个元素list遍历
if (isOper( s )) {// 如果字符串是+-*/
if (exp.isEmpty())// 如果栈是空，那么就直接入栈
exp.push( s );//-7.5*6/(-2+(-6.5- -5.22))
else if (priority( s ) <= priority( exp.peek() )) {// 如果栈里面有运算符，那么就和栈顶运算符比较优先级
rPN.add( exp.pop() );// 当前运算符优先级小于栈顶运算符，就把栈顶运算符弹出加入到后缀表达式rPN列表中
exp.push( s );// 然后压入当前运算符
} else
exp.push( s ); } else if (s.equals( ")" )) {// 如果当前字符串是‘)’那么就将栈顶字符串加入add到List rPN中，直到栈顶字符串为"("
while (!exp.peek().equals( "(" )) {
rPN.add( exp.pop() );
}
exp.pop();// 一定要记得将左括号(弹出去，代表一对小括号完成计算
} else if (s.equals( "(" ))
exp.push( s );// 如果是左括号就直接入栈
else {// 否则就是数字，直接加入rPN中
if (s.charAt( 0 ) == '-') {
rPN.add( s.substring( 1, s.length() ) );
rPN.add( "" + s.charAt( 0 ) );
minus.add( rPN.size() - 1 );//全局变量minus负号索引list集合
} else
rPN.add( s );
}
}
while (!exp.isEmpty()) {// 最后扫描完list后，将栈exp中的字符串依次加入到rPN后缀表达式列表中
rPN.add( exp.pop() );
}
return rPN;
}
计算后缀表达式思路分析图：
接下来处理运算符号：
重复以上动作，直到后缀表达式List为空，即得：
后缀表达式计算代码：
// 后缀表达式list进行计算
public double calcRPN(List<String> rPN) {
Stack<Double> numStack=new Stack<Double>();
boolean flag=false;//用来标记是否处理过负号
for (int i=0; i < rPN.size(); i++) {
if (isOper( rPN.get( i ) )) {
if (rPN.get( i ).equals( "-" )) {//这里判断两次，是为了提高查找负号索引位置的效率
for (int j=0; j < minus.size(); j++) {//遍历后缀表达式集合中记录的负号的索引下标
if (i == minus.get( j )) {//如果rPN后缀表达式的下标等于minus集合中记录的负号索引下标
String min=rPN.get( i );//说明此位置的‘-’号，为负号而不是减号
Double num=numStack.pop();//那么就pop出数栈，和-拼接
numStack.push( Double.parseDouble( min + num ) );
flag=true;
continue;
}
}
if (flag) {
flag=false;
continue;
}
}//下面就是常规计算,一定要思量上面两个continue的作用
double num1=numStack.pop();
double num2=numStack.pop();
numStack.push( calc( num1, num2, rPN.get( i ).charAt( 0 ) ) );
} else {//如果是数字就直接丢到数栈
numStack.push( Double.valueOf( rPN.get( i ) ) );
}
}
return numStack.pop();
}
接下来是完成源代码：
public class ReversePolishNotationCalcDemo {
List<Integer> minus;//用于记录符号出现的索引
public static void main(String[] args) {
String expression="-7.5*6/(-2+(-6.5- -5.22))";// 7.5 - 6.5 5.22 - - *
expression="7.5+-3*8/(7+2)";
ReversePolishNotationCalcDemo rpn=new ReversePolishNotationCalcDemo();
System.out.print( "中缀表达式为：" );
rpn.getList( expression ).forEach( System.out::print );
// for (String s : rpn.getList(expression)) {
// System.out.printf("%s ", s);
// }
System.out.println();
System.out.print( "后缀表达式为：" );
for (String s : rpn.toRPN( expression )) {
System.out.printf( "%s ", s );
}
System.out.println();
double result=rpn.calcRPN( rpn.toRPN( expression ) );
System.out.println( expression.replace( " ", "" ) + " = " + result );
}
// 后缀表达式list进行计算
public double calcRPN(List<String> rPN) {
Stack<Double> numStack=new Stack<Double>();
boolean flag=false;
for (int i=0; i < rPN.size(); i++) {
if (isOper( rPN.get( i ) )) {
if (rPN.get( i ).equals( "-" )) {
for (int j=0; j < minus.size(); j++) {
if (i == minus.get( j )) {
String min=rPN.get( i );
Double num=numStack.pop();
numStack.push( Double.parseDouble( min + num ) );
flag=true;
continue;
}
}
if (flag) {
flag=false;
continue;
}
}
double num1=numStack.pop();
double num2=numStack.pop();
numStack.push( calc( num1, num2, rPN.get( i ).charAt( 0 ) ) );
} else {
numStack.push( Double.valueOf( rPN.get( i ) ) );
}
}
return numStack.pop();
}
// 中缀表达式转后缀表达式
public List<String> toRPN(String expression) {
List<String> list=getList( expression );
List<String> rPN=new ArrayList<String>();// 用于存放后缀表达式
Stack<String> exp=new Stack<String>();// 用于操作判断符号
minus=new ArrayList<>();
for (String s : list) {// 将中缀表达式每个元素list遍历
if (isOper( s )) {// 如果字符串是+-*/
if (exp.isEmpty())// 如果栈是空，那么就直接入栈
exp.push( s );//-7.5*6/(-2+(-6.5- -5.22))
else if (priority( s ) <= priority( exp.peek() )) {// 如果栈里面有运算符，那么就和栈顶运算符比较优先级
rPN.add( exp.pop() );// 当前运算符优先级小于栈顶运算符，就把栈顶运算符弹出加入到后缀表达式rPN列表中
exp.push( s );// 然后压入当前运算符
} else
exp.push( s );
} else if (s.equals( ")" )) {// 如果当前字符串是‘)’那么就将栈顶字符串加入add到List rPN中，直到栈顶字符串为"("
while (!exp.peek().equals( "(" )) {
rPN.add( exp.pop() );
}
exp.pop();// 一定要记得将左括号(弹出去，代表一对小括号完成计算
} else if (s.equals( "(" ))
exp.push( s );// 如果是左括号就直接入栈
else {// 否则就是数字，直接加入rPN中
if (s.charAt( 0 ) == '-') {
rPN.add( s.substring( 1, s.length() ) );
rPN.add( "" + s.charAt( 0 ) );
minus.add( rPN.size() - 1 );
} else
rPN.add( s );
}
}
while (!exp.isEmpty()) {// 最后扫描完list后，将栈exp中的字符串依次加入到rPN后缀表达式列表中
rPN.add( exp.pop() );
}
System.out.println( "负号出现的索引:" + Arrays.toString( minus.toArray() ) );
return rPN;
}
// 表达式转中缀表达式(支持小数点，负数，小括号)
public List<String> getList(String expression) {
List<String> exp=new ArrayList<String>();
String merge="";
int index=0;
char ch, ch1=0;
boolean flag=false;
expression=expression.replace( " ", "" );
while (index != expression.length()) {
ch=expression.substring( index, index + 1 ).charAt( 0 );
merge+=ch;
if (index < expression.length() - 1) {// 防止下标越界
ch1=expression.substring( index + 1, index + 2 ).charAt( 0 );
if (isOper( ch1 )) {
exp.add( merge );
merge="";
flag=false;
} else if (isOper( ch )) {
if (flag == false && exp.size() > 0) {//-7.5*6/(-2+(-6.5- -5.22))
exp.add( merge );
merge="";
flag=false;
}
}
if (ch == '(' && ch1 == '-' || isOper( ch ) && ch1 == '-')
flag=true;
}
index++;
}
exp.add( merge );
return exp;
}
public boolean isOper(String oper) {
return oper.equals( "+" ) || oper.equals( "-" ) || oper.equals( "*" ) || oper.equals( "/" );
}
public boolean isOper(char oper) {
return oper == '+' || oper == '-' || oper == '*' || oper == '/' || oper == '(' || oper == ')';
}
public int priority(String s) {
if (s.equals( "+" ) || s.equals( "-" ))
return 0;
if (s.equals( "*" ) || s.equals( "/" ))
return 1;
return -1;
}
public double calc(double num1, double num2, int oper) {
switch (oper) {
case '+':
return num1 + num2;
case '-':
return num2 - num1;
case '*':
return num1 * num2;
case '/':
return num2 / num1;
default:
break;
}
return 0;
}
}完整源代码