最近上網查了一下,竟然沒有找到用Java編寫的四則運算的代碼,就小寫了一下.如有問題請大家反饋.
1.說明
代碼只是實現了簡單的四則運算,支持+,-,*,/,(,) 只能計算出正確的表達式的值,沒有對非法表達式進行校驗.
2.實現方法
第一步:將輸入的字符串轉換為List,主要是用來將String轉換為原子:數值/運算符/括號
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
public List transStr(String str) { List strList = new ArrayList(); /* 獲取提出數據的符號串 */ String tmp = str.replaceAll("\\d*", ""); /* 記錄當前的運算符 */ String curLet = null; /* 記錄tmp字符串中第一個運算符的位置 */ int loc = 0; /* 符號串長度 */ int len = tmp.length(); for (int i = 0; i < len; i++) { curLet = tmp.substring(i, i + 1); loc = str.indexOf(curLet); /* 如果當前處理字符為( 或者 ) */ if (!"".equals(str.substring(0, loc).trim())) { strList.add(str.substring(0, loc).trim()); } strList.add(str.substring(loc, loc + 1)); str = str.substring(loc + 1); } if (0 < str.length()) { strList.add(str.trim()); } return strList; } |
第二步: 將原來的中綴表達式轉換為后綴表達式,在四則運算中,后綴表達式是最方便計算的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
public String[] midToEnd(List midList) { Stack embl = new Stack(); Stack result = new Stack(); Iterator it = midList.iterator(); String curStr = null; while (it.hasNext()) { curStr = (String) it.next(); /* 確認是否式字符串 */ if(sign.containsKey(curStr)) { /* 如果符號棧為空 或者符號為( */ if (0 == embl.size() || "(".equals(curStr)) { embl.push(curStr); } else { /*如果符號為) 符號棧需要出棧,直到匹配一個(為止 */ if(")".equals(curStr)) { while(!"(".equals((String)embl.peek())) { if(0 >= embl.size()) { return null; } result.push(embl.pop()); } embl.pop(); } else { int p1 = Integer.parseInt((String) sign.get(curStr)); int p2 = Integer.parseInt((String) sign.get(embl.peek())); /* 如果當前字符的優先級大于棧頂符號的優先級 */ if (p1 > p2) { embl.push(curStr); } else { while (p1 <= p2 || embl.size() > 0) { result.push(embl.pop()); if(0 == embl.size()) { break; } p2 = Integer.parseInt((String) sign.get(embl.peek())); } embl.push(curStr); } } } } else { result.push(curStr); } } while (0 < embl.size()) { result.push(embl.pop()); } int len = result.size(); String[] ret = new String[len]; for (int i = 0; i < len; i++) { ret[len - i - 1] = (String) result.pop(); } return ret; } |
第三步:將解析后綴表達式,返回計算的最終結果
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
/** * 解析后綴表達式,返回對應的運算結果 * @param String[] endStr 轉換后的后綴表達式 * @return Object 返回運算結果 如果表達式有誤直接打印"Input Error" */ public Object calculate(String[] endStr) { int len = endStr.length; Stack calc = new Stack(); double p2; double p1; for (int i = 0; i < len; i++) { if (sign.containsKey(endStr[i])) { try { p2 = Double.parseDouble((String) calc.pop()); p1 = Double.parseDouble((String) calc.pop()); calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i]))); } catch(NumberFormatException ex) { ex.printStackTrace(); return "Input Error"; } catch(Exception ex) { ex.printStackTrace(); return "Input Error"; } } else { calc.push(endStr[i]); } } if (1 == calc.size()) { return calc.pop(); } else { return "Input Error"; } } /** * 實現底層的運算函數 * @param double p1 數字1 * @param double p1 數字2 * @param String oper 運算符 +-/* */ public double simpleCalc(double p1, double p2, String oper) { switch(oper.charAt(0)) { case '+': return p1 + p2; case '-': return p1 - p2; case '*': return p1 * p2; case '/': return p1 / p2; default: return p1; } } |
第四步:運算符的優先級放在了緩存中進行提取
|
1
2
3
4
5
6
7
8
9
10
11
|
private static HashMap sign = new HashMap();/* 將運算符的優先級放入到緩存處理 */public CalculateExp(){sign.put(")", "3");sign.put("*", "2");sign.put("/", "2");sign.put("+", "1");sign.put("-", "1");sign.put("(", "0");} |
完整代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Stack;/** * Java實現計算表達式 * 只實現有加減乘除以及括號的運算 * 例如: 3+12+25*(20-20/4)+10 * @author GuoBo 2009-3-16 * @version 1.0 */public class CalculateExp{ private static HashMap sign = new HashMap(); /* 將運算符的優先級放入到緩存處理 */ public CalculateExp() { sign.put(")", "3"); sign.put("*", "2"); sign.put("/", "2"); sign.put("+", "1"); sign.put("-", "1"); sign.put("(", "0"); } /** * @param String 輸入的表達式 * @return List 解析后的字符串元素 * 對輸入的字符串進行解析 * 轉換為需要處理的數據 * 例如:3+12+25*(20-20/4)+10 * 轉換后的結果為: * List 元素為 ret = {3,+,12,+,25,*,(,20,-,20,-,20,/,4,),+,10} */ public List transStr(String str) { List strList = new ArrayList(); /* 獲取提出數據的符號串 */ String tmp = str.replaceAll("\\d*", ""); /* 記錄當前的運算符 */ String curLet = null; /* 記錄tmp字符串中第一個運算符的位置 */ int loc = 0; /* 符號串長度 */ int len = tmp.length(); for (int i = 0; i < len; i++) { curLet = tmp.substring(i, i + 1); loc = str.indexOf(curLet); /* 如果當前處理字符為( 或者 ) */ if (!"".equals(str.substring(0, loc).trim())) { strList.add(str.substring(0, loc).trim()); } strList.add(str.substring(loc, loc + 1)); str = str.substring(loc + 1); } if (0 < str.length()) { strList.add(str.trim()); } return strList; } /** * 將表達式從中綴表達式轉換為后綴表達式(波蘭式) * @Param List 解析后的表達式的列表 * @return String[] 轉換后的表達式字符串數組 */ public String[] midToEnd(List midList) { Stack embl = new Stack(); Stack result = new Stack(); Iterator it = midList.iterator(); String curStr = null; while (it.hasNext()) { curStr = (String) it.next(); /* 確認是否式字符串 */ if(sign.containsKey(curStr)) { /* 如果符號棧為空 或者符號為( */ if (0 == embl.size() || "(".equals(curStr)) { embl.push(curStr); } else { /*如果符號為) 符號棧需要出棧,直到匹配一個(為止 */ if(")".equals(curStr)) { while(!"(".equals((String)embl.peek())) { if(0 >= embl.size()) { return null; } result.push(embl.pop()); } embl.pop(); } else { int p1 = Integer.parseInt((String) sign.get(curStr)); int p2 = Integer.parseInt((String) sign.get(embl.peek())); /* 如果當前字符的優先級大于棧頂符號的優先級 */ if (p1 > p2) { embl.push(curStr); } else { while (p1 <= p2 || embl.size() > 0) { result.push(embl.pop()); if(0 == embl.size()) { break; } p2 = Integer.parseInt((String) sign.get(embl.peek())); } embl.push(curStr); } } } } else { result.push(curStr); } } while (0 < embl.size()) { result.push(embl.pop()); } int len = result.size(); String[] ret = new String[len]; for (int i = 0; i < len; i++) { ret[len - i - 1] = (String) result.pop(); } return ret; } /** * 解析后綴表達式,返回對應的運算結果 * @param String[] endStr 轉換后的后綴表達式 * @return Object 返回運算結果 如果表達式有誤直接打印"Input Error" */ public Object calculate(String[] endStr) { int len = endStr.length; Stack calc = new Stack(); double p2; double p1; for (int i = 0; i < len; i++) { if (sign.containsKey(endStr[i])) { try { p2 = Double.parseDouble((String) calc.pop()); p1 = Double.parseDouble((String) calc.pop()); calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i]))); } catch(NumberFormatException ex) { ex.printStackTrace(); return "Input Error"; } catch(Exception ex) { ex.printStackTrace(); return "Input Error"; } } else { calc.push(endStr[i]); } } if (1 == calc.size()) { return calc.pop(); } else { return "Input Error"; } } /** * 實現底層的運算函數 * @param double p1 數字1 * @param double p1 數字2 * @param String oper 運算符 +-/* */ public double simpleCalc(double p1, double p2, String oper) { switch(oper.charAt(0)) { case '+': return p1 + p2; case '-': return p1 - p2; case '*': return p1 * p2; case '/': return p1 / p2; default: return p1; } } /** * 主控函數 */ public static void main(String[] args) { CalculateExp ce = new CalculateExp(); String tmp = "3+12+25*(20-20/4+10"; String ret = (String) ce.calculate(ce.midToEnd(ce .transStr(tmp))); double value = 0; try { value = Double.parseDouble(ret); } catch (NumberFormatException ex) { System.out.print(ret); } System.out.print(value); }} |
以下是其他網友的補充
代碼的思路是通過正則判斷計算每個最小的計算單元。以下是代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
import java.math.BigDecimal;import java.util.regex.Matcher;import java.util.regex.Pattern;/** * 計算器工具類 * @author shuqi * @date 2015-7-23 * @version since 1.0 */public class CalculatorUtil { public static BigDecimal arithmetic(String exp){ if(!exp.matches("\\d+")){ String result = parseExp(exp).replaceAll("[\\[\\]]", ""); return new BigDecimal(result); }else{ return new BigDecimal(exp); } } /** * 最小計數單位 * */ private static String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$"; /** * 不帶括號的運算 */ private static String noParentheses="^[^\\(\\)]+$"; /** * 匹配乘法或者除法 */ private static String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))"; /** * 匹配加法和減法 */ private static String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))"; /** * 匹配只帶一個括號的 */ private static String minParentheses="\\([^\\(\\)]+\\)"; /** * 解析計算四則運算表達式，例：2+((3+4)*2-22)/2*3 * @param expression * @return */ private static String parseExp(String expression){ //方法進入 先替換空格，在去除運算兩邊的()號 expression=expression.replaceAll("\\s+", "").replaceAll("^\\(([^\\(\\)]+)\\)$", "$1"); //最小表達式計算 if(expression.matches(minExp)){ String result=calculate(expression); return Double.parseDouble(result)>=0?result:"["+result+"]"; } //計算不帶括號的四則運算 if(expression.matches(noParentheses)){ Pattern patt=Pattern.compile(priorOperatorExp); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp)); }else{ patt=Pattern.compile(operatorExp); mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp)); } } return parseExp(expression); } //計算帶括號的四則運算 Pattern patt=Pattern.compile(minParentheses); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp)); } return parseExp(expression); } /** * 計算最小單位四則運算表達式（兩個數字） * @param exp * @return */ private static String calculate(String exp){ exp=exp.replaceAll("[\\[\\]]", ""); String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(","); BigDecimal number1=new BigDecimal(number[0]); BigDecimal number2=new BigDecimal(number[1]); BigDecimal result=null; String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1"); if("+".equals(operator)){ result=number1.add(number2); }else if("-".equals(operator)){ result=number1.subtract(number2); }else if("*".equals(operator)){ result=number1.multiply(number2); }else if("/".equals(operator)){ //第二個參數為精度，第三個為四色五入的模式 result=number1.divide(number2,5,BigDecimal.ROUND_CEILING); } return result!=null?result.toString():null; } } |
代碼原本是一個博客，原來代碼沒有注釋而且存在BUG，我稍微修稿了一哈添加了注釋。在這里做個筆記，方便以后用
另為表示對原作者的敬意，附上原始代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
/** * 四則運算表達式計算 * @author penli * */public class Arithmetic { public static void main(String args[]){ System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2")); } public static double arithmetic(String exp){ String result = parseExp(exp).replaceAll("[\\[\\]]", ""); return Double.parseDouble(result); } /** * 解析計算四則運算表達式，例：2+((3+4)*2-22)/2*3 * @param expression * @return */ public static String parseExp(String expression){ //String numberReg="^((?!0)\\d+(\\.\\d+(?<!0))?)|(0\\.\\d+(?<!0))$"; expression=expression.replaceAll("\\s+", "").replaceAll("^\\((.+)\\)$", "$1"); String checkExp="\\d"; String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$"; //最小表達式計算 if(expression.matches(minExp)){ String result=calculate(expression); return Double.parseDouble(result)>=0?result:"["+result+"]"; } //計算不帶括號的四則運算 String noParentheses="^[^\\(\\)]+$"; String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))"; String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))"; if(expression.matches(noParentheses)){ Pattern patt=Pattern.compile(priorOperatorExp); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp)); }else{ patt=Pattern.compile(operatorExp); mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp)); } } return parseExp(expression); } //計算帶括號的四則運算 String minParentheses="\\([^\\(\\)]+\\)"; Pattern patt=Pattern.compile(minParentheses); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp)); } return parseExp(expression); } /** * 計算最小單位四則運算表達式（兩個數字） * @param exp * @return */ public static String calculate(String exp){ exp=exp.replaceAll("[\\[\\]]", ""); String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(","); BigDecimal number1=new BigDecimal(number[0]); BigDecimal number2=new BigDecimal(number[1]); BigDecimal result=null; String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1"); if("+".equals(operator)){ result=number1.add(number2); }else if("-".equals(operator)){ result=number1.subtract(number2); }else if("*".equals(operator)){ result=number1.multiply(number2); }else if("/".equals(operator)){ result=number1.divide(number2); } return result!=null?result.toString():null; }} |
最后給大家分享一個網友的實現方法，個人感覺也很不錯
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
import java.util.Stack; /** * 利用棧，進行四則運算的類 * 用兩個棧來實現算符優先，一個棧用來保存需要計算的數據numStack,一個用來保存計算優先符priStack * * 基本算法實現思路為：用當前取得的運算符與priStack棧頂運算符比較優先級：若高于，則因為會先運算，放入棧頂； * 若等于，因為出現在后面，所以會后計算，所以棧頂元素出棧，取出操作數運算； * 若小于，則同理，取出棧頂元素運算，將結果入操作數棧。各個優先級'(' > '*' = '/' > '+' = '-' > ')' * */public class Operate { private Stack<Character> priStack = new Stack<Character>();// 操作符棧 private Stack<Integer> numStack = new Stack<Integer>();;// 操作數棧 /** * 傳入需要解析的字符串，返回計算結果(此處因為時間問題，省略合法性驗證) * @param str 需要進行技術的表達式 * @return 計算結果 */ public int caculate(String str) { // 1.判斷string當中有沒有非法字符 String temp;// 用來臨時存放讀取的字符 // 2.循環開始解析字符串，當字符串解析完，且符號棧為空時，則計算完成 StringBuffer tempNum = new StringBuffer();// 用來臨時存放數字字符串(當為多位數時) StringBuffer string = new StringBuffer().append(str);// 用來保存，提高效率 while (string.length() != 0) { temp = string.substring(0, 1); string.delete(0, 1); // 判斷temp，當temp為操作符時 if (!isNum(temp)) { // 1.此時的tempNum內即為需要操作的數，取出數，壓棧，并且清空tempNum if (!"".equals(tempNum.toString())) { // 當表達式的第一個符號為括號 int num = Integer.parseInt(tempNum.toString()); numStack.push(num); tempNum.delete(0, tempNum.length()); } // 用當前取得的運算符與棧頂運算符比較優先級：若高于，則因為會先運算，放入棧頂；若等于，因為出現在后面，所以會后計算，所以棧頂元素出棧，取出操作數運算； // 若小于，則同理，取出棧頂元素運算，將結果入操作數棧。 // 判斷當前運算符與棧頂元素優先級，取出元素，進行計算(因為優先級可能小于棧頂元素，還小于第二個元素等等，需要用循環判斷) while (!compare(temp.charAt(0)) && (!priStack.empty())) { int a = (int) numStack.pop();// 第二個運算數 int b = (int) numStack.pop();// 第一個運算數 char ope = priStack.pop(); int result = 0;// 運算結果 switch (ope) { // 如果是加號或者減號，則 case '+': result = b + a; // 將操作結果放入操作數棧 numStack.push(result); break; case '-': result = b - a; // 將操作結果放入操作數棧 numStack.push(result); break; case '*': result = b * a; // 將操作結果放入操作數棧 numStack.push(result); break; case '/': result = b / a;// 將操作結果放入操作數棧 numStack.push(result); break; } } // 判斷當前運算符與棧頂元素優先級， 如果高，或者低于平，計算完后，將當前操作符號，放入操作符棧 if (temp.charAt(0) != '#') { priStack.push(new Character(temp.charAt(0))); if (temp.charAt(0) == ')') {// 當棧頂為'('，而當前元素為')'時，則是括號內以算完，去掉括號 priStack.pop(); priStack.pop(); } } } else // 當為非操作符時（數字） tempNum = tempNum.append(temp);// 將讀到的這一位數接到以讀出的數后(當不是個位數的時候) } return numStack.pop(); } /** * 判斷傳入的字符是不是0-9的數字 * * @param str * 傳入的字符串 * @return */ private boolean isNum(String temp) { return temp.matches("[0-9]"); } /** * 比較當前操作符與棧頂元素操作符優先級，如果比棧頂元素優先級高，則返回true，否則返回false * * @param str 需要進行比較的字符 * @return 比較結果 true代表比棧頂元素優先級高，false代表比棧頂元素優先級低 */ private boolean compare(char str) { if (priStack.empty()) { // 當為空時，顯然 當前優先級最低，返回高 return true; } char last = (char) priStack.lastElement(); // 如果棧頂為'('顯然，優先級最低，')'不可能為棧頂。 if (last == '(') { return true; } switch (str) { case '#': return false;// 結束符 case '(': // '('優先級最高,顯然返回true return true; case ')': // ')'優先級最低， return false; case '*': { // '*/'優先級只比'+-'高 if (last == '+' || last == '-') return true; else return false; } case '/': { if (last == '+' || last == '-') return true; else return false; } // '+-'為最低，一直返回false case '+': return false; case '-': return false; } return true; } public static void main(String args[]) { Operate operate = new Operate(); int t = operate.caculate("(3+4*(4*10-10/2)#"); System.out.println(t); } } |
