一道笔试题：按照用户输入的rule，经过并、交、差运算后，输出字符串结果。

今天在CSDN看到一个笔试题，觉得蛮有意思的，

题目如下：

从事先写好的Input.txt文件中读取数，
Input.txt 内容
A{13，2，1，20，30，50}
B{1，2，34，5，6}
C{2，3，12，23，14，11}
用户在键盘随意敲入...例如((A*B))+B-C,((C+B)*A)-B期中+,*，-,分别代表集合的并交差运算，控制台打印输出。

开始的时候打算用栈来计算的，

但想了想，不会搞，还是来个笨方法吧。

废话不多说，贴代码。

代码写的很烂，汗了！

1. /**
2. *从事先写好的Input.txt文件中读取数，
3. *Input.txt内容
4. *A{13，2，1，20，30，50}
5. *B{1，2，34，5，6}
6. *C{2，3，12，23，14，11}
7. *用户在键盘随意敲入...例如((A*B))+B-C,((C+B)*A)-B期中+,*，-,分别代表集合的并交差运算，控制台打印输出。
8. */
9. packagecom.lim.test;
11. importjava.io.BufferedReader;
12. importjava.io.FileInputStream;
13. importjava.io.IOException;
14. importjava.io.InputStreamReader;
15. importjava.lang.reflect.InvocationTargetException;
16. importjava.lang.reflect.Method;
17. importjava.util.ArrayList;
18. importjava.util.List;
20. /**
21. *@authorbzwm
22. *
23. */
24. publicclassEditorString{
25. privateTypea=null;
27. privateTypeb=null;
29. privateTypec=null;
31. privateTypet=null;
33. /**
34. *读入指定的文件
35. *
36. *@parampath
37. */
38. publicvoidreadFile(Stringpath){
39. BufferedReaderreader=null;
40. try{
41. reader=newBufferedReader(newInputStreamReader(
42. newFileInputStream(path)));
43. Stringstr=null;
44. while((str=reader.readLine())!=null){
46. if(str.substring(0,1).equals("A")){
47. a=newType(str);
48. }elseif(str.substring(0,1).equals("B")){
49. b=newType(str);
50. }elseif(str.substring(0,1).equals("C")){
51. c=newType(str);
52. }elseif(str.substring(0,1).equals("T")){
53. t=newType(str);
54. }else{
55. System.out.println("nosuchtype!");
56. return;
57. }
58. }
59. }catch(Exceptione){
60. e.printStackTrace();
61. return;
62. }
63. }
65. /**
66. *处理并、交、差操作，显示结果
67. *
68. *@paramrule
69. */
70. publicvoiddisplayResult(Stringrule){
71. intstart=0;
72. intend=0;
73. while(rule.length()>2){
74. if(rule.contains("(")){
75. start=rule.lastIndexOf("(");
76. end=start+4;
77. rule=execute(start,end,rule);
78. }else{
79. start=0;
80. end=start+2;
81. rule=executeNormal(start,end,rule);
82. }
83. }
84. Listresult=t.getArray();
85. for(inti=0;i<result.size();i++)
86. System.out.println(result.get(i));
87. }
89. /**
90. *处理并、交、差操作
91. *
92. *@paramstart
93. *@paramend
94. *@paramrule
95. *@returnrule
96. */
97. privateStringexecute(intstart,intend,Stringrule){
98. intsize=rule.length();
99. Typeobj=typeFactory(rule.substring(start+1,start+2));
100. Stringope=rule.substring(start+2,start+3);
101. Typearg=typeFactory(rule.substring(end-1,end));
102. try{
103. t=execute(obj,arg,ope);
104. }catch(Exceptione){
105. e.printStackTrace();
106. }
107. returnrule.substring(0,start)+"T"+rule.substring(end+1,size);
108. }
109. /**
110. *当用户输入的rule没有括号的情况：处理并、交、差操作
111. *@paramstart
112. *@paramend
113. *@paramrule
114. *@returnrule
115. */
116. privateStringexecuteNormal(intstart,intend,Stringrule){
117. intsize=rule.length();
118. Typeobj=typeFactory(rule.substring(start,start+1));
119. Stringope=rule.substring(start+1,start+2);
120. Typearg=typeFactory(rule.substring(end,end+1));
121. try{
122. t=execute(obj,arg,ope);
123. }catch(Exceptione){
124. e.printStackTrace();
125. }
126. returnrule.substring(0,start)+"T"+rule.substring(end+1,size);
127. }
129. /**
130. *根据ope的不同，调用不同的方法
131. *
132. *@paramobj
133. *@paramarg
134. *@paramope
135. *@return
136. *@throwsSecurityException
137. *@throwsNoSuchMethodException
138. *@throwsIllegalArgumentException
139. *@throwsIllegalAccessException
140. *@throwsInvocationTargetException
141. */
142. privateTypeexecute(Typeobj,Typearg,Stringope)
143. throwsSecurityException,NoSuchMethodException,
144. IllegalArgumentException,IllegalAccessException,
145. InvocationTargetException{
146. Classc=obj.getClass();
147. Class[]args=newClass[1];
148. args[0]=arg.getClass();
149. Methodm=null;
150. if(ope.equals("+")){
151. m=c.getMethod("bing",args);
152. }elseif(ope.equals("*")){
153. m=c.getMethod("jiao",args);
154. }elseif(ope.equals("-")){
155. m=c.getMethod("cha",args);
156. }else{
157. System.out.println("NoSuchMethod");
158. returnnull;
159. }
160. return(Type)m.invoke(obj,newObject[]{arg});
161. }
163. /**
164. *读入用户输入的匹配规则如：((C+B)*A)-B
165. *
166. *@return
167. */
168. publicstaticStringreadInput(){
169. Stringret=null;
170. BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
171. try{
172. ret=br.readLine();
173. }catch(IOExceptione){
174. e.printStackTrace();
175. returnnull;
176. }
177. returnret;
178. }
180. /**
181. *构造工厂
182. *
183. *@paramtype
184. *@return
185. */
186. privateTypetypeFactory(Stringtype){
187. if(type.equals("A")){
188. returnnewType(a.getArray());
189. }elseif(type.equals("B")){
190. returnnewType(b.getArray());
191. }elseif(type.equals("C")){
192. returnnewType(c.getArray());
193. }elseif(type.equals("T")){
194. returnnewType(t.getArray());
195. }else{
196. returnnull;
197. }
198. }
200. /**
201. *把如{13,2,1,20,30,50}的集合抽象成一个类，提供并、交、差操作
202. *
203. *@authorbzwm
204. *
205. */
206. classType{
207. privateListarray=newArrayList();
209. publicType(Stringsrt){
210. this.array=createList(srt);
211. }
213. publicType(Listlist){
214. this.array.addAll(list);
215. }
217. publicListgetArray(){
218. returnthis.array;
219. }
221. /**
222. *并操作
223. *
224. *@paramarg
225. *@return
226. */
227. publicTypebing(Typearg){
228. //是否加入到集合中的标志
229. booleanadd=true;
230. //取出传入的Type对象的List
231. Listlist=arg.getArray();
232. //遍历传入的Type对象的List
233. for(inti=0;i<list.size();i++){
234. add=true;
235. //与array里的值一一进行比较，如果全都不等，则加入到原array中，否则不加入
236. for(intj=0;j<array.size();j++){
237. if(((Integer)list.get(i)).intValue()==((Integer)array
238. .get(j)).intValue()){
239. add=false;
240. }
241. }
242. if(add){
243. array.add(list.get(i));
244. }
245. }
246. //返回新的Type对象
247. returnnewType(array);
248. }
250. /**
251. *交操作
252. *
253. *@paramarg
254. *@return
255. */
256. publicTypejiao(Typearg){
257. //是否加入到集合中的标志
258. booleanadd=false;
259. //存放交集数据的List
260. Listret=newArrayList();
261. //取出传入的Type对象的List
262. Listlist=arg.getArray();
263. //遍历传入的Type对象的List
264. for(inti=0;i<list.size();i++){
265. add=false;
266. //与array里的值一一进行比较，如果有相等的，则加入到ret中，否则不加入
267. for(intj=0;j<array.size();j++){
268. if(((Integer)list.get(i)).intValue()==((Integer)array
269. .get(j)).intValue()){
270. add=true;
271. }
272. }
273. if(add){
274. ret.add(list.get(i));
275. }
276. }
277. //返回新的Type对象
278. returnnewType(ret);
279. }
281. /**
282. *差操作
283. *
284. *@paramarg
285. *@return
286. */
287. publicTypecha(Typearg){
288. //是否加入到集合中的标志
289. booleanadd=true;
290. //存放交集数据的List
291. Listlist=arg.getArray();
292. //遍历传入的Type对象的List
293. for(inti=0;i<list.size();i++){
294. add=true;
295. //与array里的值一一进行比较，如果有相等的，则从原array中将其删除，如果全都不等，则加入到原array中
296. for(intj=0;j<array.size();j++){
297. if(((Integer)list.get(i)).intValue()==((Integer)array
298. .get(j)).intValue()){
299. add=false;
300. //删除相等的数据
301. array.remove(j);
302. }
303. }
304. if(add){
305. array.add(list.get(i));
306. }
307. }
308. //返回新的Type对象
309. returnnewType(array);
310. }
312. /**
313. *解析字符串，将数字加入到List中
314. *
315. *@paramstr
316. *@return
317. */
318. privateListcreateList(Stringstr){
319. //将字符串解析成字符串数组A{13,2,1,20,30,50}-->newString[]{13,2,1,20,30,50}
320. Strings[]=str.replaceAll(str.substring(0,1),"").replace("{",
321. "").replace("}","").split(",");
322. Listlist=newArrayList();
323. for(inti=0;i<s.length;i++){
324. list.add(newInteger(s[i]));
325. }
326. returnlist;
327. }
328. }
330. /**
331. *测试程序
332. *@paramargs
333. */
334. publicstaticvoidmain(Stringargs[]){
335. EditorStringes=newEditorString();
336. es.readFile("input.txt");
337. es.displayResult(readInput());//((C+B)*A)-B
338. }
339. }

写完这个程序之后，该睡觉了，也没测试！

有问题了再说啊！