在Java中计算四则运算表达式字符串的值

原文链接：http://zywang.iteye.com/blog/462797

在项目中有个需求，需要动态的计算一个四则运算表达式的结果，在JS中做这个非常方便，用eval表达式就搞定了，但在Java语言里就没那么容易了，上网搜了一下没有找到满意的，小弟不才，网上很多代码看不明白，唉，无奈下，自己利用Java中的正则表达式做了一个简单的包括了加减乘除及小括号的计算方法。因为时间仓促，为了赶进度，没仔细进行验证，现在贴出来，请大家拍拍砖，有什么好的解决方法，或考虑到效率问题，还请多多指教。

套话少说了，我的程序的思路是：

1、首先循环获取取最小单位的小括号表达式进行加减乘除计算，直到表达式中不包含小括号为止

2、然后对每个不含括号的表达式，在按顺序执行乘除法，直到没有乘除法表达式

3、最后计算所有的加减表达式，执行的顺序就是按顺序执行了

    a）对于负数运算，首先将其负号去除，同时将相应运算单元的加减号转换，然后再进行运算

Java代码  

1. import java.text.DecimalFormat;  
2. import java.text.NumberFormat;  
3. import java.text.SimpleDateFormat;  
4. import java.util.regex.Matcher;  
5. import java.util.regex.Pattern;  
6.   
7. /** 
8.  * 报表工具类 
9.  * @author ZYWANG 2009-7-28 
10.  */  
11. public final class ReportUtil {  
12.     /** 
13.      * 格式化日期 
14.      * @param obj 日期对象 
15.      * @param format 格式化字符串 
16.      * @return 
17.      * @author ZYWANG 2009-8-26 
18.      */  
19.     public static String formatDate(Object obj, String format) {  
20.         if (obj == null)  
21.             return "";  
22.   
23.         String s = String.valueOf(obj);  
24.         if (format == null || "".equals(format.trim())) {  
25.             format = "yyyy-MM-dd";  
26.         }  
27.         try {  
28.             SimpleDateFormat dateFormat = new SimpleDateFormat(format);  
29.             s = dateFormat.format(obj);  
30.         } catch (Exception e) {  
31.         }  
32.         return s;  
33.     }  
34.   
35.     /** 
36.      * 格式化数字 
37.      * @param obj 数字对象 
38.      * @param format 格式化字符串 
39.      * @return 
40.      * @author ZYWANG 2009-8-26 
41.      */  
42.     public static String formatNumber(Object obj, String format) {  
43.         if (obj == null)  
44.             return "";  
45.   
46.         String s = String.valueOf(obj);  
47.         if (format == null || "".equals(format.trim())) {  
48.             format = "#.00";  
49.         }  
50.         try {  
51.             if (obj instanceof Double || obj instanceof Float) {  
52.                 if (format.contains("%")) {  
53.                     NumberFormat numberFormat = NumberFormat.getPercentInstance();  
54.                     s = numberFormat.format(obj);  
55.                 } else {  
56.                     DecimalFormat decimalFormat = new DecimalFormat(format);  
57.                     s = decimalFormat.format(obj);  
58.                 }  
59.             } else {  
60.                 NumberFormat numberFormat = NumberFormat.getInstance();  
61.                 s = numberFormat.format(obj);  
62.             }  
63.         } catch (Exception e) {  
64.         }  
65.         return s;  
66.     }  
67.   
68.     /** 
69.      * 计算字符串四则运算表达式 
70.      * @param string 
71.      * @return 
72.      * @author ZYWANG 2009-8-31 
73.      */  
74.     public static String computeString(String string) {  
75.         String regexCheck = "[\\(\\)\\d\\+\\-\\*/\\.]*";// 是否是合法的表达式  
76.   
77.         if (!Pattern.matches(regexCheck, string))  
78.             return string;  
79.   
80.         Matcher matcher = null;  
81.         String temp = "";  
82.         int index = -1;  
83.         String regex = "\\([\\d\\.\\+\\-\\*/]+\\)";// 提取括号表达式  
84.         string = string.replaceAll("\\s", "");// 去除空格  
85.         try {  
86.             Pattern pattern = Pattern.compile(regex);  
87.             // 循环计算所有括号里的表达式  
88.             while (pattern.matcher(string).find()) {  
89.                 matcher = pattern.matcher(string);  
90.                 while (matcher.find()) {  
91.                     temp = matcher.group();  
92.                     index = string.indexOf(temp);  
93.                     string = string.substring(0, index)  
94.                             + computeStirngNoBracket(temp)  
95.                             + string.substring(index + temp.length());  
96.                 }  
97.             }  
98.             // 最后计算总的表达式结果  
99.             string = computeStirngNoBracket(string);  
100.         } catch (NumberFormatException e) {  
101.             return e.getMessage();  
102.         }  
103.         return string;  
104.     }  
105.   
106.     /** 
107.      * 计算不包含括号的表达式 
108.      * @param string 
109.      * @return 
110.      * @author ZYWANG 2009-8-31 
111.      */  
112.     private static String computeStirngNoBracket(String string) {  
113.         string = string.replaceAll("(^\\()|(\\)$)", "");  
114.         String regexMultiAndDivision = "[\\d\\.]+(\\*|\\/)[\\d\\.]+";  
115.         String regexAdditionAndSubtraction = "(^\\-)?[\\d\\.]+(\\+|\\-)[\\d\\.]+";  
116.   
117.         String temp = "";  
118.         int index = -1;  
119.   
120.         // 解析乘除法  
121.         Pattern pattern = Pattern.compile(regexMultiAndDivision);  
122.         Matcher matcher = null;  
123.         while (pattern.matcher(string).find()) {  
124.             matcher = pattern.matcher(string);  
125.             if (matcher.find()) {  
126.                 temp = matcher.group();  
127.                 index = string.indexOf(temp);  
128.                 string = string.substring(0, index) + doMultiAndDivision(temp)  
129.                         + string.substring(index + temp.length());  
130.             }  
131.         }  
132.   
133.         // 解析加减法  
134.         pattern = Pattern.compile(regexAdditionAndSubtraction);  
135.         while (pattern.matcher(string).find()) {  
136.             matcher = pattern.matcher(string);  
137.             if (matcher.find()) {  
138.                 temp = matcher.group();  
139.                 index = string.indexOf(temp);  
140.                 if (temp.startsWith("-")) {  
141.                     string = string.substring(0, index)  
142.                             + doNegativeOperation(temp)  
143.                             + string.substring(index + temp.length());  
144.                 } else {  
145.                     string = string.substring(0, index)  
146.                             + doAdditionAndSubtraction(temp)  
147.                             + string.substring(index + temp.length());  
148.                 }  
149.             }  
150.         }  
151.   
152.         return string;  
153.     }  
154.   
155.     /** 
156.      * 执行乘除法 
157.      * @param string 
158.      * @return 
159.      * @author ZYWANG 2009-8-31 
160.      */  
161.     private static String doMultiAndDivision(String string) {  
162.         String value = "";  
163.         double d1 = 0;  
164.         double d2 = 0;  
165.         String[] temp = null;  
166.         if (string.contains("*")) {  
167.             temp = string.split("\\*");  
168.         } else {  
169.             temp = string.split("/");  
170.         }  
171.   
172.         if (temp.length < 2)  
173.             return string;  
174.   
175.         d1 = Double.valueOf(temp[0]);  
176.         d2 = Double.valueOf(temp[1]);  
177.         if (string.contains("*")) {  
178.             value = String.valueOf(d1 * d2);  
179.         } else {  
180.             value = String.valueOf(d1 / d2);  
181.         }  
182.   
183.         return value;  
184.     }  
185.   
186.     /** 
187.      * 执行加减法 
188.      * @param string 
189.      * @return 
190.      * @author ZYWANG 2009-8-31 
191.      */  
192.     private static String doAdditionAndSubtraction(String string) {  
193.         double d1 = 0;  
194.         double d2 = 0;  
195.         String[] temp = null;  
196.         String value = "";  
197.         if (string.contains("+")) {  
198.             temp = string.split("\\+");  
199.         } else {  
200.             temp = string.split("\\-");  
201.         }  
202.   
203.         if (temp.length < 2)  
204.             return string;  
205.   
206.         d1 = Double.valueOf(temp[0]);  
207.         d2 = Double.valueOf(temp[1]);  
208.         if (string.contains("+")) {  
209.             value = String.valueOf(d1 + d2);  
210.         } else {  
211.             value = String.valueOf(d1 - d2);  
212.         }  
213.   
214.         return value;  
215.     }  
216.   
217.     /** 
218.      * 执行负数运算 
219.      * @param string 
220.      * @return 
221.      * @author ZYWANG 2010-11-8 
222.      */  
223.     private static String doNegativeOperation(String string) {  
224.         String temp = string.substring(1);  
225.         if (temp.contains("+")) {  
226.             temp = temp.replace("+", "-");  
227.         } else {  
228.             temp = temp.replace("-", "+");  
229.         }  
230.         temp = doAdditionAndSubtraction(temp);  
231.         if (temp.startsWith("-")) {  
232.             temp = temp.substring(1);  
233.         } else {  
234.             temp = "-" + temp;  
235.         }  
236.         return temp;  
237.     }  
238.   
239.     public static void main(String[] args) {  
240.         String s = "1-7+8";  
241.         s = computeString(s);  
242.         System.out.println(s);  
243.     }  
244. }  

 特别感谢lping2指出了负数运算的计算BUG。