续上一篇文章，用栈来实现：按照用户输入的rule，经过并、交、差运算后，输出字符串结果。

废话不说了，

文件：

A{1,2,3,4,5,6}
B{7,4,5,6,8}
C{2,3,12,14,4,11}

测试时输入到控制台的字符串为：

C+B-(A*(C-A))+B

结果：

2 3 12 14 4 11 7 8 1 5 6

自己算了一下，是正确的！

代码如下，注释也写的蛮多的：

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;
19. importjava.util.Stack;
21. /**
22. *@authorbzwm
23. *
24. */
25. publicclassEditorStringV2{
26. //保存住集合A中的数据
27. privateTypetypeA=null;
29. //保存住集合B中的数据
30. privateTypetypeB=null;
32. //保存住集合C中的数据
33. privateTypetypeC=null;
35. privateStackstack=newStack();
37. publicEditorStringV2(Stringpath){
38. readFile(path);
39. }
41. /**
42. *读入指定的文件
43. *
44. *@parampath
45. */
46. privatevoidreadFile(Stringpath){
47. BufferedReaderreader=null;
48. try{
49. reader=newBufferedReader(newInputStreamReader(
50. newFileInputStream(path)));
51. Stringstr=null;
52. //保存已经写好的文件中A,B,C的集合
53. while((str=reader.readLine())!=null){
54. //保存集合A
55. if(str.substring(0,1).equals("A")){
56. typeA=newType(str);
57. }
58. //保存集合B
59. elseif(str.substring(0,1).equals("B")){
60. typeB=newType(str);
61. }
62. //保存集合C
63. elseif(str.substring(0,1).equals("C")){
64. typeC=newType(str);
65. }else{
66. System.out.println("nosuchtype!");
67. return;
68. }
69. }
70. }catch(Exceptione){
71. e.printStackTrace();
72. return;
73. }
74. }
76. /**
77. *处理并、交、差操作，显示结果
78. *
79. *@paramrule
80. *例：C-((C+B)-A)*B
81. *@throwsInvocationTargetException
82. *@throwsIllegalAccessException
83. *@throwsNoSuchMethodException
84. *@throwsIllegalArgumentException
85. *@throwsSecurityException
86. */
87. publicStackdisplayResult(StackorgStack)throwsSecurityException,
88. IllegalArgumentException,NoSuchMethodException,
89. IllegalAccessException,InvocationTargetException{
90. //左括号"("的计数器
91. intleftBracket=0;
92. //是否存在操作符标志符
93. booleanhasOpe=false;
94. //输入的rule的长度
95. intlength=orgStack.size();
96. Objectobj=null;
97. if(length<3){
98. System.out.println("inputruleisillegal.");
99. returnnull;
100. }else{
101. for(inti=0;i<length;i++){
102. //截取rule的每个字符
103. obj=orgStack.pop();
104. //如果是左括号，则leftBracket加1
105. if(isLeftBracket(obj)){
106. leftBracket+=1;
107. stack.push(obj);
108. continue;
109. }
110. //如果是操作符，则将操作符标志符置为true
111. if(isOperator(obj)){
112. hasOpe=true;
113. stack.push(obj);
114. continue;
115. }
116. //如果不是左括号和操作符则入栈
117. stack.push(obj);
118. //如果左括号存在，且本次字符为右括号
119. if(leftBracket>0&&isRightBracket(obj)){
120. //将右括号弹出栈
121. stack.pop();
122. //将形如typeA.bing(typeB)的方法调用的参数标志弹出
123. Typearg=(Type)stack.pop();
124. //将形如typeA.bing(typeB)的方法调用的操作符标志弹出：+/bing*/jiao-/cha
125. Stringope=stack.pop().toString();
126. //将形如typeA.bing(typeB)的方法调用的主调对象标志弹出
127. TypeinvokeObj=(Type)stack.pop();
128. //通过对象工厂,构造出Type对象,进行并、交、差操作,返回得到的新Type对象
129. TypetypeTmp=execute(invokeObj,ope,arg);
130. //将左括号弹出栈
131. stack.pop();
132. //左括号计数器减1
133. leftBracket-=1;
134. //栈中加入临时的Type对象标志T,T代表本次操作后得到的新集合
135. stack.push(typeTmp);
136. //当栈中还有运算时，进行递归
137. if(stack.size()>2){
138. StacktmpStack=newStack();
139. while(stack.size()>0){
140. tmpStack.push(stack.pop());
141. }
142. stack=displayResult(tmpStack);
143. }
144. continue;
145. }
147. //如果1.栈中还没有左括号2.栈有操作符3.本次字符是集合标志A、B、C
148. //则进行并、交、差操作
149. if(leftBracket==0&&hasOpe&&isType(obj)){
150. //将形如typeA.bing(typeB)的方法调用的参数标志弹出
151. Typearg=(Type)stack.pop();
152. //将形如typeA.bing(typeB)的方法调用的操作符标志弹出：+/bing*/jiao-/cha
153. Stringope=stack.pop().toString();
154. //将形如typeA.bing(typeB)的方法调用的主调对象标志弹出
155. TypeinvokeObj=(Type)stack.pop();
156. //通过对象工厂,构造出Type对象,进行并、交、差操作,返回得到的新Type对象
157. TypetypeTmp=execute(invokeObj,ope,arg);
158. //栈中加入临时的Type对象标志T,T代表本次操作后得到的新集合
159. stack.push(typeTmp);
160. //将操作符标志符置为false
161. hasOpe=false;
162. //当栈中还有运算时，进行递归
163. if(stack.size()>2){
164. StacktmpStack=newStack();
165. while(stack.size()>0){
166. tmpStack.push(stack.pop());
167. }
168. stack=displayResult(tmpStack);
169. }
170. continue;
171. }
172. }
173. //循环结束,得到最后结果
174. returnstack;
175. }
176. }
178. /**
179. *判断对象o是否为Type的实例
180. *
181. *@paramo
182. *@return
183. */
184. privatebooleanisType(Objecto){
185. returnoinstanceofType;
186. }
188. /**
189. *判断对象o是否为操作符*,+,-
190. *
191. *@paramo
192. *@return
193. */
194. privatebooleanisOperator(Objecto){
195. return!isType(o)&&((String)o).matches("[+//*-]");
196. }
198. /**
199. *判断对象o是否左括号"("
200. *
201. *@paramo
202. *@return
203. */
204. privatebooleanisLeftBracket(Objecto){
205. return!isType(o)&&((String)o).equals("(");
206. }
208. /**
209. *判断对象o是否右括号")"
210. *
211. *@paramo
212. *@return
213. */
214. privatebooleanisRightBracket(Objecto){
215. return!isType(o)&&((String)o).equals(")");
216. }
218. /**
219. *利用反射机制，根据ope的不同，调用不同的方法
220. *
221. *@paramobj
222. *@paramarg
223. *@paramope
224. *@return
225. *@throwsSecurityException
226. *@throwsNoSuchMethodException
227. *@throwsIllegalArgumentException
228. *@throwsIllegalAccessException
229. *@throwsInvocationTargetException
230. */
231. privateTypeexecute(Typeobj,Stringope,Typearg)
232. throwsSecurityException,NoSuchMethodException,
233. IllegalArgumentException,IllegalAccessException,
234. InvocationTargetException{
235. Classc=obj.getClass();
236. Class[]args=newClass[1];
237. args[0]=arg.getClass();
238. Methodm=null;
239. //如果操作符为"+"，则执行bing方法
240. if(ope.equals("+")){
241. m=c.getMethod("bing",args);
242. }
243. //如果操作符为"*"，则执行jiao方法
244. elseif(ope.equals("*")){
245. m=c.getMethod("jiao",args);
246. }
247. //如果操作符为"-"，则执行cha方法
248. elseif(ope.equals("-")){
249. m=c.getMethod("cha",args);
250. }else{
251. System.out.println("NoSuchMethod");
252. returnnull;
253. }
254. return(Type)m.invoke(obj,newObject[]{arg});
255. }
257. /**
258. *读入用户输入的匹配规则如：((C+B)*A)-B
259. *
260. *@return
261. */
262. privateStackreadInput(){
263. Stackret=newStack();
264. Stringstr=null;
265. Stringo=null;
266. BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
267. try{
268. str=br.readLine();
269. }catch(IOExceptione){
270. e.printStackTrace();
271. returnnull;
272. }
273. for(inti=str.length();i>0;i--){
274. o=str.substring(i-1,i);
275. //当遇到A,B,C时，生成Type对象存入栈中
276. if(o.matches("[ABC]")){
277. ret.push(typeFactory(o));
278. continue;
279. }
280. ret.push(o);
281. }
282. returnret;
283. }
285. /**
286. *构造工厂根据传入的type构造Type对象保存住原集合
287. *
288. *@paramtype
289. *@return
290. */
291. privateTypetypeFactory(Stringtype){
292. if(type.equals("A")){
293. returnnewType(typeA.getArray());
294. }elseif(type.equals("B")){
295. returnnewType(typeB.getArray());
296. }elseif(type.equals("C")){
297. returnnewType(typeC.getArray());
298. }else{
299. returnnull;
300. }
301. }
303. /**
304. *把如{13,2,1,20,30,50}的集合抽象成一个类，提供并、交、差操作
305. *
306. *@authorbzwm
307. *
308. */
309. classType{
310. //保存数据集合的List
311. privateListarray=newArrayList();
313. publicType(Stringsrt){
314. this.array=createList(srt);
315. }
317. publicType(Listlist){
318. this.array.addAll(list);
319. }
321. publicListgetArray(){
322. returnthis.array;
323. }
325. /**
326. *并操作
327. *
328. *@paramarg
329. *@return
330. */
331. publicTypebing(Typearg){
332. //是否加入到集合中的标志
333. booleanadd=true;
334. //取出传入的Type对象的List
335. Listlist=arg.getArray();
336. //遍历传入的Type对象的List
337. for(inti=0;i<list.size();i++){
338. add=true;
339. //与array里的值一一进行比较，如果全都不等，则加入到原array中，否则不加入
340. for(intj=0;j<array.size();j++){
341. if(((Integer)list.get(i)).intValue()==((Integer)array
342. .get(j)).intValue()){
343. add=false;
344. }
345. }
346. if(add){
347. array.add(list.get(i));
348. }
349. }
350. //返回新的Type对象
351. returnnewType(array);
352. }
354. /**
355. *交操作
356. *
357. *@paramarg
358. *@return
359. */
360. publicTypejiao(Typearg){
361. //是否加入到集合中的标志
362. booleanadd=false;
363. //存放交集数据的List
364. Listret=newArrayList();
365. //取出传入的Type对象的List
366. Listlist=arg.getArray();
367. //遍历传入的Type对象的List
368. for(inti=0;i<list.size();i++){
369. add=false;
370. //与array里的值一一进行比较，如果有相等的，则加入到ret中，否则不加入
371. for(intj=0;j<array.size();j++){
372. if(((Integer)list.get(i)).intValue()==((Integer)array
373. .get(j)).intValue()){
374. add=true;
375. }
376. }
377. if(add){
378. ret.add(list.get(i));
379. }
380. }
381. //返回新的Type对象
382. returnnewType(ret);
383. }
385. /**
386. *差操作
387. *
388. *@paramarg
389. *@return
390. */
391. publicTypecha(Typearg){
392. //是否加入到集合中的标志
393. booleanadd=true;
394. //存放交集数据的List
395. Listlist=arg.getArray();
396. //遍历传入的Type对象的List
397. for(inti=0;i<list.size();i++){
398. add=true;
399. //与array里的值一一进行比较，如果有相等的，则从原array中将其删除，如果全都不等，则加入到原array中
400. for(intj=0;j<array.size();j++){
401. if(((Integer)list.get(i)).intValue()==((Integer)array
402. .get(j)).intValue()){
403. add=false;
404. //删除相等的数据
405. array.remove(j);
406. }
407. }
408. if(add){
409. array.add(list.get(i));
410. }
411. }
412. //返回新的Type对象
413. returnnewType(array);
414. }
416. /**
417. *解析字符串，将数字加入到List中
418. *
419. *@paramstr
420. *@return
421. */
422. privateListcreateList(Stringstr){
423. //将字符串解析成字符串数组A{13,2,1,20,30,50}-->newString[]{13,2,1,20,30,50}
424. Strings[]=str.replaceAll(str.substring(0,1),"").replace("{",
425. "").replace("}","").split(",");
426. Listlist=newArrayList();
427. for(inti=0;i<s.length;i++){
428. list.add(newInteger(s[i]));
429. }
430. returnlist;
431. }
432. }
434. /**
435. *测试程序
436. *
437. *@paramargs
438. *@throwsInvocationTargetException
439. *@throwsIllegalAccessException
440. *@throwsNoSuchMethodException
441. *@throwsIllegalArgumentException
442. *@throwsSecurityException
443. */
444. publicstaticvoidmain(Stringargs[])throwsSecurityException,
445. IllegalArgumentException,NoSuchMethodException,
446. IllegalAccessException,InvocationTargetException{
447. EditorStringV2es=newEditorStringV2("input.txt");
448. Stacks=es.readInput();
449. Stackresult=es.displayResult(s);//((C+B)*A)-B
451. Listlist=((Type)result.pop()).getArray();
452. System.out.println("操作运算后结果为：");
453. for(inti=0;i<list.size();i++)
454. System.out.print(list.get(i)+"");
455. }
456. }