/**
* 1.先转换为逆波兰顺序
* 数字直接存入list,符号压入栈中,但是如果栈底元素不大于该运算符的运算顺序,则将栈底pop,直到大于栈底运算符为止,再压入栈中,
* 最后将运算符依次全部pop(以上pop出的运算符存入list)
* 2.根据逆序算出结果
* 从头到尾依次读取list的数据,将数字压入栈中,出现运算符后pop出两个数字进行运算,运算式为"后pop数 运算符 先pop数"
* 运算完毕将结果再次压入栈中.结束后,将数字栈中的唯一一个数字pop出并将其返回.
*
*
* 学习之处:
* 1.String对象的比较不要用==,>,<.而是用equal()函数.
* 2.使用HashMap<Object,Integer>()的定义可以给对象进行编号或加权.
* 3.需要时要给读取的信息加上结尾标志,如读入String结尾的"#".
* 4.取String的单个字母:String temps=String.valueOf(expression.charAt(i));
* 5.检测数字:temps.matches("[0-9.]")
**/
public class Calculator {
private String string;
private MyStack<String> opratorStack = new MyStack();
private MyStack<Double> numberStack = new MyStack();
private ArrayList<String> rpnList = new ArrayList();
private Map<String,Integer> priorityMap=new HashMap<String,Integer>();//用于存储操作符优先级的Map
//初始化优先级约定(可根据计算的复杂程度扩展)
public Calculator(String str)
{
priorityMap.put("+",0);
priorityMap.put("-",0);
priorityMap.put("*", 1);
priorityMap.put("/", 1);
priorityMap.put("(", 2);
string = str+"#";
}
private int getPriority(String op)//得到一个操作符的优先级
{
return priorityMap.get(op);
}
private void toRpn() {
String temp = "";
for (int i = 0; i < string.length(); i++) {
String ch = String.valueOf(string.charAt(i));
if (ch.matches("[0-9.]"))
temp += ch;
else { //如果操作数完整,现将其存入list中再进行后续操作
if(!temp.equals("")) {//防止加入进空格
rpnList.add(temp);
temp = "";
}
if (ch.equals("#")) { //读取结束时将运算符栈依次pop并添加到rpnList中
while (!opratorStack.isEmpty()) {
rpnList.add(opratorStack.pop());
}
} else if (ch.equals(")")) { //遇到右括号将左括号后的运算符全部pop
String op = opratorStack.pop();
while (!op .equals("(")) {
rpnList.add(op);
op = opratorStack.pop();
}
} else {
if (!opratorStack.isEmpty()) { //如果为普通的运算符
String endOprator = opratorStack.endValue();
while (!endOprator.equals( "(") && (getPriority(ch) < getPriority(endOprator)
|| getPriority(ch) == getPriority(endOprator))) {
rpnList.add(opratorStack.pop());//如果
if (!opratorStack.isEmpty()) {
endOprator = opratorStack.endValue();
}else
break;
}
opratorStack.push(ch);
}
else
opratorStack.push(ch);
}
}
}
}
public double calculate(String string){
this.string = string+"#";
return calculate();
}
public double calculate(){
toRpn();//逆波兰序列转换
//扫描String对象
for(int i = 0; i < rpnList.size(); i++){
String temp = rpnList.get(i);
//匹配第一个字符,为数字的则将String对象转为Double并存入numberStack中
if(String.valueOf(temp.charAt(0)).matches("[0-9]")){
numberStack.push(Double.valueOf(temp));
} //匹配到运算符,调出最后两个numberStack中数字进行运算,并将得数压入栈中(栈次底数 操作符 栈最底数)
else {
//Double n = opration(numberStack.pop(), numberStack.pop(), temp);
Double n = numberStack.pop();
numberStack.push(opration(numberStack.pop(), n , temp));
}
}
rpnList = new ArrayList();//为下次运算做准备
return numberStack.pop();
}
private Double opration(Double val1,Double val2,String oprator){
if(oprator.equals("+"))
val1 += val2;
else if(oprator.equals("-"))
val1 -= val2;
else if(oprator.equals("*"))
val1 *= val2;
else
val1 /= val2;
return val1;
}
public static void main(String[] args) {
String string1 = "12+2*37-(4*5+6)*7";
Calculator calculator = new Calculator(string1);
System.out.println(calculator.calculate());
System.out.println(calculator.calculate("4.99+5.99+6.99*1.06"));
}
}
运算结果:
-96.0
18.389400000000002
Process finished with exit code 0