java实现计算算术表达式的值(后缀表达式方式)

标签：

Java代码  

1. package zn.sd.ly.jtree.test;  
2.   
3. /** 
4.  * 表达式 
5.  *  
6.  * @author 风华褚胜--刘胜军 
7.  */  
8. import java.util.Arrays;  
9. import java.util.Scanner;  
10. import java.util.Stack;  
11.   
12. public class Four {  
13.     @SuppressWarnings("resource")  
14.     public static void main(String[] args) {  
15.         Scanner sc = new Scanner(System.in);  
16.         System.out.println("请输入标准表达式(exit退出)：");  
17.         String str = sc.nextLine();  
18.         while (!str.equals("exit")) {  
19.             if (judge_kuohao(str)) {  
20.                 System.out.println("括号匹配成功！");  
21.                 System.out.println(jisuan(getHouzhui(f(str))));  
22.             } else {  
23.                 System.out.println("括号匹配不成功，或者包含不规则括号！");  
24.             }  
25.             System.out.println("请输入标准表达式(exit退出)：");  
26.             str = sc.nextLine();  
27.         }  
28.     }  
29.   
30.     /** 
31.      *  
32.      * @param str 
33.      *            传入的完整算术表达试字符串 
34.      * @return 返回boolean值，如果匹配成功，返回true，反之false 
35.      */  
36.     public static boolean judge_kuohao(String str) {  
37.         Stack<Character> s = new Stack<Character>();  
38.         /**********************************/  
39.         char[] ch = new char[128];  
40.         ch[‘1‘] = ‘1‘;  
41.         ch[‘2‘] = ‘2‘;  
42.         ch[‘3‘] = ‘3‘;  
43.         ch[‘4‘] = ‘4‘;  
44.         ch[‘5‘] = ‘5‘;  
45.         ch[‘6‘] = ‘6‘;  
46.         ch[‘7‘] = ‘7‘;  
47.         ch[‘8‘] = ‘8‘;  
48.         ch[‘9‘] = ‘9‘;  
49.         ch[‘0‘] = ‘0‘;  
50.         ch[‘(‘] = ‘(‘;  
51.         ch[‘)‘] = ‘)‘;  
52.         ch[‘[‘] = ‘[‘;  
53.         ch[‘]‘] = ‘]‘;  
54.         ch[‘{‘] = ‘{‘;  
55.         ch[‘}‘] = ‘}‘;  
56.         ch[‘.‘] = ‘.‘;  
57.         ch[‘+‘] = ‘+‘;  
58.         ch[‘-‘] = ‘-‘;  
59.         ch[‘*‘] = ‘*‘;  
60.         ch[‘/‘] = ‘/‘;  
61.         /**********************************/  
62.         for (int i = 0; i < str.length(); i++) {  
63.             char t = str.charAt(i);  
64.             if (t > 128 || ch[t] != t) {  
65.                 return false;  
66.             }  
67.             if (t == ‘(‘ || t == ‘[‘ || t == ‘{‘) {  
68.                 s.push(t);  
69.             } else if (t == ‘)‘ || t == ‘]‘ || t == ‘}‘) {  
70.                 char temp = ‘\u0000‘;  
71.                 if (s.size() > 0)  
72.                     temp = s.pop();  
73.                 else  
74.                     return false;  
75.                 if (!((temp == ‘(‘ && t == ‘)‘) || (temp == ‘[‘ && t == ‘]‘) || (temp == ‘{‘ && t == ‘}‘))) {  
76.                     return false;  
77.                 }  
78.             } else {  
79.   
80.             }  
81.         }  
82.         if (s.size() != 0)  
83.             return false;  
84.         return true;  
85.         /**********************************/  
86.     }  
87.   
88.     /** 
89.      *  
90.      * @param str 
91.      *            传入的完整算术表达试字符串 
92.      * @return 完整算术表达试字符串中每个元素组合而成的数组 
93.      */  
94.     public static Object[] f(String str) {  
95.         Stack<Object> s = new Stack<Object>();  
96.         int left = 0, right = 0, tag = ((str.charAt(0) >= ‘0‘ && str.charAt(0) <= ‘9‘)  
97.                 || (str.charAt(0) == ‘.‘) ? 0 : 1);  
98.         for (int i = 0; i < str.length(); i++) {  
99.             char t = str.charAt(i);  
100.             if ((t >= ‘0‘ && t <= ‘9‘) || (t == ‘.‘)) {  
101.                 right++;  
102.                 tag = 0;  
103.             } else {  
104.                 if (left != right) {  
105.                     s.push(new Double(str.substring(left, right)));  
106.                     left = right;  
107.                 }  
108.                 right++;  
109.                 s.push(str.substring(left, right));  
110.                 left = right;  
111.                 tag = 1;  
112.             }  
113.             if (right == str.length()) {  
114.                 if (left != right) {  
115.                     if (tag == 1)  
116.                         s.push(str.substring(left, right));  
117.                     else  
118.                         s.push(new Double(str.substring(left, right)));  
119.                     left = right;  
120.                 }  
121.             }  
122.         }  
123.         System.out.println(Arrays.toString(s.toArray()));  
124.         return s.toArray();  
125.     }  
126.   
127.     /** 
128.      * 获取后缀表达式 
129.      *  
130.      * @param f 
131.      *            完整算术表达试字符串中每个元素组合而成的数组 
132.      * @return 后缀表达式数组 
133.      */  
134.     public static Object[] getHouzhui(Object[] f) {  
135.         Stack<Object> s = new Stack<Object>();  
136.         Stack<Object> n = new Stack<Object>();  
137.         for (int i = 0; i < f.length; i++) {  
138.             if (f[i].equals("(") || f[i].equals("[") || f[i].equals("{")) {  
139.                 s.push("(");  
140.             } else if (f[i].equals("*")) {  
141.                 while ("/".equals((s.size() > 0) ? s.lastElement() : "")) {  
142.                     n.push(s.pop());  
143.                 }  
144.                 s.push("*");  
145.             } else if (f[i].equals("/")) {  
146.                 while ("*".equals((s.size() > 0) ? s.lastElement() : "")) {  
147.                     n.push(s.pop());  
148.                 }  
149.                 s.push("/");  
150.             } else if (f[i].equals("+")) {  
151.                 while (("*".equals((s.size() > 0) ? s.lastElement() : ""))  
152.                         || ("/").equals((s.size() > 0) ? s.lastElement() : "")  
153.                         || ("-").equals((s.size() > 0) ? s.lastElement() : "")) {  
154.                     n.push(s.pop());  
155.                 }  
156.                 s.push("+");  
157.             } else if (f[i].equals("-")) {  
158.                 while (("*".equals((s.size() > 0) ? s.lastElement() : ""))  
159.                         || ("/").equals((s.size() > 0) ? s.lastElement() : "")  
160.                         || ("+").equals((s.size() > 0) ? s.lastElement() : "")) {  
161.                     n.push(s.pop());  
162.                 }  
163.                 s.push("-");  
164.             } else if (f[i].equals(")") || f[i].equals("]") || f[i].equals("}")) {  
165.                 while (!"(".equals((s.size() > 0) ? s.lastElement() : "")) {  
166.                     n.push(s.pop());  
167.                 }  
168.                 s.pop();  
169.             } else {  
170.                 n.push(f[i]);  
171.             }  
172.         }  
173.         while (s.size() > 0)  
174.             n.push(s.pop());  
175.         return n.toArray();  
176.     }  
177.   
178.     /** 
179.      * 计算 
180.      *  
181.      * @param f 
182.      * @return 
183.      */  
184.     public static double jisuan(Object[] f) {  
185.         Stack<Object> s = new Stack<Object>();  
186.         for (int i = 0; i < f.length; i++) {  
187.             if (f[i] instanceof Double) {  
188.                 s.push(f[i]);  
189.             } else if ("+".equals(f[i])) {  
190.                 double left = (double) s.pop();  
191.                 double right = (double) s.pop();  
192.                 s.push(jia(right, left));  
193.             } else if ("-".equals(f[i])) {  
194.                 double left = (double) s.pop();  
195.                 double right = (double) s.pop();  
196.                 s.push(jian(right, left));  
197.             } else if ("*".equals(f[i])) {  
198.                 double left = (double) s.pop();  
199.                 double right = (double) s.pop();  
200.                 s.push(cheng(right, left));  
201.             } else if ("/".equals(f[i])) {  
202.                 double left = (double) s.pop();  
203.                 double right = (double) s.pop();  
204.                 s.push(chu(right, left));  
205.             } else {  
206.   
207.             }  
208.         }  
209.         return (double) s.pop();  
210.     }  
211.   
212.     public static double jia(double a, double b) {  
213.         return a + b;  
214.     }  
215.   
216.     public static double jian(double a, double b) {  
217.         return a - b;  
218.     }  
219.   
220.     public static double cheng(double a, double b) {  
221.         return a * b;  
222.     }  
223.   
224.     public static double chu(double a, double b) {  
225.         return a / b;  
226.     }  
227. }  

》》源码地址获取

springmvc + mybatis整合详细，及遇到的问题请参看以下资料：

参考资料：

http://www.springmvc,net/detail/6074493.html

http://my.spring.net/wangbiglei/blog/489583

http://my.springmvc.net/wangbiglei/blog/489604

java实现计算算术表达式的值(后缀表达式方式)

标签：

原文地址：http://www.cnblogs.com/lucene110/p/4857525.html