java 解析四则混合运算表达式并计算结果

1. package ch8;
3. import java.util.LinkedList;
4. import java.util.List;
5. import java.util.Stack;
7. /**
8. * 四则混合运算表达式计算
9. * @author Jinjichao
10. *
11. */
12. public class Calculator {
14.     /**
15.      * 运算符枚举
16.      * @author Jinjichao
17.      *
18.      */
19.     private enum Operator {
20.         ADD("+", 10), SUBTRACT("-", 10), MULTIPLY("*", 20), DIVIDE("/", 20),
21.         PARENTHESIS_LEFT("(", 100), PARENTHESIS_RIGHT(")", 100);
23.         private String operator;
24.         private int priority;
25.         private Operator(String operator, int priority) {
26.             this.operator = operator;
27.             this.priority = priority;
28.         }
29.     }
31.     /**
32.      * 操作数枚举
33.      * @author Jinjichao
34.      *
35.      */
36.     private enum Operand {
37.         ONE("1"), TWO("2"), THREE("3"), FOUR("4"), FIVE("5"), SIX("6"),
38.         SEVEN("7"), EIGHT("8"), NINE("9"), ZERO("0"), POINT(".");
40.         private String operand;
41.         private Operand(String operand) {
42.             this.operand = operand;
43.         }
44.     }
45.    
46.     /**
47.      * 获取字符串所对应的运算符枚举
48.      * @param str
49.      * @return
50.      */
51.     private Operator getOperator(String str) {
52.         for (Operator op : Operator.values()) {
53.             if (str.equals(op.operator)) {
54.                 return op;
55.             }
56.         }
57.         return null;
58.     }
60.     /**
61.      * 获取字符串所对应的操作数枚举
62.      * @param str
63.      * @return
64.      */
65.     private Operand getOperand(String str) {
66.         for (Operand op : Operand.values()) {
67.             if (str.equals(op.operand)) {
68.                 return op;
69.             }
70.         }
71.         return null;
72.     }   
74.     /**
75.      * 第1步: 将运算表达式字符串分解为运算表达式List
76.      *
77.      * @param exp
78.      * @return
79.      */
80.     private List<String> resolveExpr(String exp) {
81.         List<String> list = new LinkedList<String>();
82.         String temp = "";
83.         exp = exp.replace(" ", "");
84.         for (int i = 0; i < exp.length(); i++) {
85.             String str = exp.substring(i, i + 1);
86.             Operator op = getOperator(str);
87.             Operand od = getOperand(str);
88.             if (op != null) {
89.                 if (!temp.isEmpty()) {
90.                     list.add(temp);
91.                     temp = "";
92.                 }
93.                 list.add(str);
94.             } else if (od != null) {
95.                 temp += str;
96.             } else {
97.                 System.out.println("表达式[" + str + "]非法! ");
98.                 return null;
99.             }
100.         }
101.         if (!temp.isEmpty()) {
102.             list.add(temp);
103.         }
104.         //System.out.println(list);
105.         return list;
106.     }
108.     /**
109.      * 第2步: 将运算表达式List转换为逆波兰表达式List
110.      * @param expList
111.      * @return
112.      */
113.     private List<String> dealExpr(List<String> expList) {
114.         if(expList == null) {
115.             return null;
116.         }
117.         
118.         List<String> list = new LinkedList<String>();
119.         Stack<String> stack = new Stack<String>();
120.         for (String str : expList) {
121.             Operator op = getOperator(str.substring(0, 1));
122.             Operand od = getOperand(str.substring(0, 1));
123.             if (od != null) {
124.                 //操作数直接入队列
125.                 list.add(str);
126.             } else if (op != null) {
127.                 if (Operator.PARENTHESIS_LEFT.equals(op)) {
128.                     //左括号入栈
129.                     stack.push(str);
130.                 } else if (Operator.PARENTHESIS_RIGHT.equals(op)) {
131.                     //右括号: 循环将栈顶的运算符取出并存入队列，直到取出左括号
132.                     while (true) {
133.                         if (stack.empty()) {
134.                             System.out.println("缺少左括号! ");
135.                             return null;
136.                         } else if (Operator.PARENTHESIS_LEFT.operator.equals(stack.peek())) {
137.                             stack.pop();
138.                             break;
139.                         } else {
140.                             list.add(stack.pop());
141.                         }
142.                     }
143.                 } else {
144.                     //非括号类运算符
145.                     if (!stack.empty()) {
146.                         Operator top_op = getOperator(stack.peek());
147.                         //当前运算符优先级大于栈顶运算符优先级，或者栈顶为左括号时，当前运算符直接入栈
148.                         if(op.priority > top_op.priority
149.                                 || Operator.PARENTHESIS_LEFT.equals(top_op)) {
150.                             stack.push(str);
151.                         }
152.                         //否则，将栈顶的运算符取出并存入队列，然后将自己入栈
153.                         else {
154.                             list.add(stack.pop());
155.                             stack.push(str);
156.                         }                        
157.                     } else {
158.                         stack.push(str);
159.                     }
160.                 }
161.             }
162.         }
163.         while(!stack.empty()) {
164.             String str = stack.peek();
165.             if(Operator.PARENTHESIS_LEFT.operator.equals(str)) {
166.                 System.out.println("缺少右括号! ");
167.                 return null;
168.             } else {
169.                 list.add(stack.pop());
170.             }
171.         }
172.         //System.out.println(list);
173.         return list;
174.     }
175.    
176.     /**
177.      * 操作数运算
178.      * @param x
179.      * @param y
180.      * @param op
181.      * @return
182.      */
183.     private String operation(String x, String y, Operator op) {
184.         double a = 0.0;
185.         double b = 0.0;
186.         try {
187.             a = Double.parseDouble(x);
188.             b = Double.parseDouble(y);
189.         } catch (NumberFormatException e) {
190.             System.out.println("操作数非法! ");
191.             e.printStackTrace();
192.         }
193.         
194.         switch (op) {
195.         case ADD:
196.             return String.valueOf(a + b);
197.         case SUBTRACT:
198.             return String.valueOf(a - b);
199.         case MULTIPLY:
200.             return String.valueOf(a * b);
201.         case DIVIDE:
202.             return String.valueOf(a / b);
203.         default:
204.             return null;
205.         }
206.     }
207.    
208.     /**
209.      * 第3步: 逆波兰表达式运算
210.      * @param exp
211.      * @return
212.      */
213.     public String calculate(String exp) {
214.         List<String> expList = dealExpr(resolveExpr(exp));
215.         if(expList == null) {
216.             return null;
217.         }
218.         Stack<String> stack = new Stack<String>();
219.         for(String str : expList) {
220.             Operator op = getOperator(str.substring(0, 1));
221.             Operand od = getOperand(str.substring(0, 1));
222.             if(od != null) {
223.                 stack.push(str);
224.             } else if (op != null) {
225.                 //目前仅针对二元运算符
226.                 String x = "";
227.                 String y = "";
228.                 if(!stack.empty()) {
229.                     y = stack.pop();
230.                 }
231.                 if(!stack.empty()) {
232.                     x = stack.pop();
233.                 }               
234.                 if(!x.isEmpty() && !x.isEmpty()) {
235.                     String result = operation(x, y, op);
236.                     if(result == null) {
237.                         return null;
238.                     }
239.                     stack.push(result);
240.                 } else {
241.                     return null;
242.                 }
243.             }
244.         }
245.         return stack.pop();
246.     }   
248. }

复制代码

测试一下：

1. package ch8;
3. /**
4. * 测试
5. * @author Jinjichao
6. *
7. */
8. public class Test {
10.     public static void main(String[] args) {
11.         Calculator cal = new Calculator();
12.         String str = cal.calculate("( ( ( 15 / 3 ) + ( 1.5 * 2 ) + ( 20 - 12 ))  - 3.2 +2.3 + 5 ) ");
13.         System.out.println("运算结果:" + str);
15.     }
17. }

复制代码

运行结果：
运算结果:20.1
其他的测试案例：

<IGNORE_JS_OP>

1.jpg (15.44 KB)

下载附件  保存到相册

2015-8-22 16:54 上传

 

<IGNORE_JS_OP>

2.jpg (16.65 KB)

下载附件  保存到相册

2015-8-22 16:54 上传

 

<IGNORE_JS_OP>

3.jpg (19.76 KB)

下载附件  保存到相册

2015-8-22 16:54 上传

 

算法原理（对照截图）：
第1步、将表达式字符串分解为运算表达式List（将运算符和操作数分别分解出来）
第2步：将运算表达式List转换为逆波兰表达式List
第3步：逆波兰表达式运算