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步：逆波蘭表達式運算