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

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

复制代码

测试一下：

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

复制代码

运行结果：
运算结果: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步：逆波兰表达式运算