栈的规则是先进后出。利用压栈的思想来计算四则运算表达式是这样的：我们给定两个栈，一个用来存放数字、一个用来存放对应的操作符。假定我们有一个给定的四则运算表达式a+b+c/d*(e+f)-d*a，那我们先把这个表达式拆分成一个个的数字或者是运算符、或者就是括号了。然后我们从左至右遍历每一个元素，遍历过程中遵循步骤和原则如下：
（1）遇到数字则直接压到数字栈顶。
（2）遇到运算符（+-*/）时，若操作符栈为空，则直接放到操作符栈顶，否则，见（3）。
（3）若操作符栈顶元素的优先级比当前运算符的优先级小，则直接压入栈顶，否则执行步骤（4）。
（4）弹出数字栈顶的两个数字并弹出操作符栈顶的运算符进行运算，把运算结果压入数字栈顶，重复（2）和（3）直到当前运算符被压入操作符栈顶。
（5）遇到左括号“（”时则直接压入操作符栈顶。
（6）遇到右括号“）”时则依次弹出操作符栈顶的运算符运算数字栈的最顶上两个数字，直到弹出的操作符为左括号。
下面的例子中分别使用java.util.Vector和java.util.Stack基于上述原则实现了这一运算过程。
1. import
2. import
3. import
4. import
5. import
6. import
7.
8. public class
9.
10. public static void
11. "1 + 5 * 6 + 3 * (2 + 3*2+2-1+3*3) + 10/5 - 6*1";
12. new
13. double
14. double
15. "======="
16. }
17.
18. /**
19. * 利用java.util.Vector计算四则运算字符串表达式的值，如果抛出异常，则说明表达式有误，这里就没有控制
20. * @param computeExpr 四则运算字符串表达式
21. * @return 计算结果
22. */
23. public double
24. new StringTokenizer(computeExpr, "+-*/()", true);
25. new
26. new
27. this.getComputeOper();
28. Operator curOper;
29. String currentEle;
30. while
31. currentEle = tokenizer.nextToken().trim();
32. if (!"".equals(currentEle)) {//只处理非空字符
33. if (this.isNum(currentEle)) { // 数字
34. nums.add(Double.valueOf(currentEle));
35. else { // 非数字，即括号或者操作符
36. curOper = computeOper.get(currentEle);
37. if (curOper != null) { // 是运算符
38. // 运算列表不为空且之前的运算符优先级较高则先计算之前的优先级
39. while
40. && operators.lastElement().priority() >= curOper
41. .priority()) {
42. compute(nums, operators);
43. }
44. // 把当前运算符放在运算符队列的末端
45. operators.add(curOper);
46. else { // 括号
47. if ("(".equals(currentEle)) { // 左括号时直接放入操作列表中
48. operators.add(Operator.BRACKETS);
49. else {// 当是右括号的时候就把括号里面的内容执行了。
50. // 循环执行括号里面的内容直到遇到左括号为止。试想这种情况(2+5*2)
51. while
52. compute(nums, operators);
53. }
54. //移除左括号
55. 1);
56. }
57. }
58. }
59. }
60. }
61. // 经过上面代码的遍历后最后的应该是nums里面剩两个数或三个数，operators里面剩一个或两个运算操作符
62. while
63. compute(nums, operators);
64. }
65. return
66. }
67.
68. /**
69. * 利用java.util.Stack计算四则运算字符串表达式的值，如果抛出异常，则说明表达式有误，这里就没有控制
70. * java.util.Stack其实也是继承自java.util.Vector的。
71. * @param computeExpr 四则运算字符串表达式
72. * @return 计算结果
73. */
74. public double
75. //把表达式用运算符、括号分割成一段一段的，并且分割后的结果包含分隔符
76. new StringTokenizer(computeExpr, "+-*/()", true);
77. new Stack<Double>(); //用来存放数字的栈
78. new Stack<Operator>(); //存放操作符的栈
79. this.getComputeOper(); //获取运算操作符
80. //当前元素
81. while
82. //去掉前后的空格
83. if (!"".equals(currentEle)) { //只处理非空字符
84. if (this.isNum(currentEle)) { //为数字时则加入到数字栈中
85. numStack.push(Double.valueOf(currentEle));
86. else { //操作符
87. //获取当前运算操作符
88. if (currentOper != null) { //不为空时则为运算操作符
89. while
90. compute(numStack, operStack);
91. }
92. //计算完后把当前操作符加入到操作栈中
93. operStack.push(currentOper);
94. else {//括号
95. if ("(".equals(currentEle)) { //左括号时加入括号操作符到栈顶
96. operStack.push(Operator.BRACKETS);
97. else { //右括号时, 把左括号跟右括号之间剩余的运算符都执行了。
98. while
99. compute(numStack, operStack);
100. }
101. //移除栈顶的左括号
102. }
103. }
104. }
105. }
106. }
107. // 经过上面代码的遍历后最后的应该是nums里面剩两个数或三个数，operators里面剩一个或两个运算操作符
108. while
109. compute(numStack, operStack);
110. }
111. return
112. }
113.
114. /**
115. * 判断一个字符串是否是数字类型
116. * @param str
117. * @return
118. */
119. private boolean
120. "^\\d+(\\.\\d+)?$"; //数字的正则表达式
121. return
122. }
123.
124. /**
125. * 获取运算操作符
126. * @return
127. */
128. private
129. return new HashMap<String, Operator>() { // 运算符
130. private static final long
131. {
132. "+", Operator.PLUS);
133. "-", Operator.MINUS);
134. "*", Operator.MULTIPLY);
135. "/", Operator.DIVIDE);
136. }
137. };
138. }
139.
140. /**
141. * 取nums的最后两个数字，operators的最后一个运算符进行运算，然后把运算结果再放到nums列表的末端
142. * @param nums
143. * @param operators
144. */
145. private void
146. 1); // 第二个数字，当前队列的最后一个数字
147. 1); // 第一个数字，当前队列的最后一个数字
148. 1).compute(
149. // 取最后一个运算符进行计算
150. // 把计算结果重新放到队列的末端
151. }
152.
153. /**
154. * 取numStack的最顶上两个数字，operStack的最顶上一个运算符进行运算，然后把运算结果再放到numStack的最顶端
155. * @param numStack 数字栈
156. * @param operStack 操作栈
157. */
158. private void
159. // 弹出数字栈最顶上的数字作为运算的第二个数字
160. // 弹出数字栈最顶上的数字作为运算的第一个数字
161. Double computeResult = operStack.pop().compute(
162. // 弹出操作栈最顶上的运算符进行计算
163. // 把计算结果重新放到队列的末端
164. }
165.
166. /**
167. * 运算符
168. */
169. private enum
170. /**
171. * 加
172. */
173. PLUS {
174. @Override
175. public int
176. return 1;
177. }
178.
179. @Override
180. public double compute(double num1, double
181. return
182. }
183. },
184. /**
185. * 减
186. */
187. MINUS {
188. @Override
189. public int
190. return 1;
191. }
192.
193. @Override
194. public double compute(double num1, double
195. return
196. }
197. },
198. /**
199. * 乘
200. */
201. MULTIPLY {
202. @Override
203. public int
204. return 2;
205. }
206.
207. @Override
208. public double compute(double num1, double
209. return
210. }
211. },
212. /**
213. * 除
214. */
215. DIVIDE {
216. @Override
217. public int
218. return 2;
219. }
220.
221. @Override
222. public double compute(double num1, double
223. return
224. }
225. },
226. /**
227. * 括号
228. */
229. BRACKETS {
230. @Override
231. public int
232. return 0;
233. }
234.
235. @Override
236. public double compute(double num1, double
237. return 0;
238. }
239. };
240. /**
241. * 对应的优先级
242. * @return
243. */
244. public abstract int
245.
246. /**
247. * 计算两个数对应的运算结果
248. * @param num1 第一个运算数
249. * @param num2 第二个运算数
250. * @return
251. */
252. public abstract double compute(double num1, double
253. }
254. }