最近上网查了一下,竟然没有找到用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); } } |
