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

guo583

浏览: 75541 次
性别:
来自: 厦门

最近访客更多访客>>

angel20082008

shunshuiyuanxin

zwljava

直下看山河

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

废话不说了，

文件：

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

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

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

/**
*从事先写好的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期中+,*，-,分别代表集合的并交差运算，控制台打印输出。

*/
packagecom.lim.test;
importjava.io.BufferedReader;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Stack;

/**
*@authorbzwm
*

*/

publicclassEditorStringV2{

//保存住集合A中的数据 

privateTypetypeA=null;

//保存住集合B中的数据 

privateTypetypeB=null;

//保存住集合C中的数据 

privateTypetypeC=null;

privateStackstack=newStack();

publicEditorStringV2(Stringpath){
readFile(path);
}

/**
*读入指定的文件
*
*@parampath

*/

privatevoidreadFile(Stringpath){

BufferedReaderreader=null;

try{

reader=newBufferedReader(newInputStreamReader(

newFileInputStream(path)));

Stringstr=null;

//保存已经写好的文件中A,B,C的集合 

while((str=reader.readLine())!=null){

//保存集合A 

if(str.substring(0,1).equals("A")){

typeA=newType(str);
}

//保存集合B 

elseif(str.substring(0,1).equals("B")){

typeB=newType(str);
}

//保存集合C 

elseif(str.substring(0,1).equals("C")){

typeC=newType(str);

}else{

System.out.println("nosuchtype!");

return;
}
}

}catch(Exceptione){
e.printStackTrace();

return;
}
}

/**
*处理并、交、差操作，显示结果
*
*@paramrule
*例：C-((C+B)-A)*B
*@throwsInvocationTargetException
*@throwsIllegalAccessException
*@throwsNoSuchMethodException
*@throwsIllegalArgumentException
*@throwsSecurityException

*/

publicStackdisplayResult(StackorgStack)throwsSecurityException,
IllegalArgumentException,NoSuchMethodException,
IllegalAccessException,InvocationTargetException{

//左括号"("的计数器 

intleftBracket=0;

//是否存在操作符标志符 

booleanhasOpe=false;

//输入的rule的长度 

intlength=orgStack.size();

Objectobj=null;

if(length<3){

System.out.println("inputruleisillegal.");

returnnull;

}else{

for(inti=0;i<length;i++){

//截取rule的每个字符 
obj=orgStack.pop();

//如果是左括号，则leftBracket加1 

if(isLeftBracket(obj)){
leftBracket+=1;
stack.push(obj);

continue;
}

//如果是操作符，则将操作符标志符置为true 

if(isOperator(obj)){

hasOpe=true;
stack.push(obj);

continue;
}

//如果不是左括号和操作符则入栈 
stack.push(obj);

//如果左括号存在，且本次字符为右括号 

if(leftBracket>0&&isRightBracket(obj)){

//将右括号弹出栈 
stack.pop();

//将形如typeA.bing(typeB)的方法调用的参数标志弹出 
Typearg=(Type)stack.pop();

//将形如typeA.bing(typeB)的方法调用的操作符标志弹出：+/bing*/jiao-/cha 
Stringope=stack.pop().toString();

//将形如typeA.bing(typeB)的方法调用的主调对象标志弹出 
TypeinvokeObj=(Type)stack.pop();

//通过对象工厂,构造出Type对象,进行并、交、差操作,返回得到的新Type对象 
TypetypeTmp=execute(invokeObj,ope,arg);

//将左括号弹出栈 
stack.pop();

//左括号计数器减1 
leftBracket-=1;

//栈中加入临时的Type对象标志T,T代表本次操作后得到的新集合 
stack.push(typeTmp);

//当栈中还有运算时，进行递归 

if(stack.size()>2){

StacktmpStack=newStack();

while(stack.size()>0){
tmpStack.push(stack.pop());
}
stack=displayResult(tmpStack);
}

continue;
}

//如果1.栈中还没有左括号2.栈有操作符3.本次字符是集合标志A、B、C 

//则进行并、交、差操作 

if(leftBracket==0&&hasOpe&&isType(obj)){

//将形如typeA.bing(typeB)的方法调用的参数标志弹出 
Typearg=(Type)stack.pop();

//将形如typeA.bing(typeB)的方法调用的操作符标志弹出：+/bing*/jiao-/cha 
Stringope=stack.pop().toString();

//将形如typeA.bing(typeB)的方法调用的主调对象标志弹出 
TypeinvokeObj=(Type)stack.pop();

//通过对象工厂,构造出Type对象,进行并、交、差操作,返回得到的新Type对象 
TypetypeTmp=execute(invokeObj,ope,arg);

//栈中加入临时的Type对象标志T,T代表本次操作后得到的新集合 
stack.push(typeTmp);

//将操作符标志符置为false 

hasOpe=false;

//当栈中还有运算时，进行递归 

if(stack.size()>2){

StacktmpStack=newStack();

while(stack.size()>0){
tmpStack.push(stack.pop());
}
stack=displayResult(tmpStack);
}

continue;
}
}

//循环结束,得到最后结果 

returnstack;
}
}

/**
*判断对象o是否为Type的实例
*
*@paramo
*@return

*/

privatebooleanisType(Objecto){

returnoinstanceofType;
}

/**
*判断对象o是否为操作符*,+,-
*
*@paramo
*@return

*/

privatebooleanisOperator(Objecto){

return!isType(o)&&((String)o).matches("[+//*-]");
}

/**
*判断对象o是否左括号"("
*
*@paramo
*@return

*/

privatebooleanisLeftBracket(Objecto){

return!isType(o)&&((String)o).equals("(");
}

/**
*判断对象o是否右括号")"
*
*@paramo
*@return

*/

privatebooleanisRightBracket(Objecto){

return!isType(o)&&((String)o).equals(")");
}

/**
*利用反射机制，根据ope的不同，调用不同的方法
*
*@paramobj
*@paramarg
*@paramope
*@return
*@throwsSecurityException
*@throwsNoSuchMethodException
*@throwsIllegalArgumentException
*@throwsIllegalAccessException
*@throwsInvocationTargetException

*/

privateTypeexecute(Typeobj,Stringope,Typearg)
throwsSecurityException,NoSuchMethodException,
IllegalArgumentException,IllegalAccessException,
InvocationTargetException{
Classc=obj.getClass();

Class[]args=newClass[1];
args[0]=arg.getClass();

Methodm=null;

//如果操作符为"+"，则执行bing方法 

if(ope.equals("+")){

m=c.getMethod("bing",args);
}

//如果操作符为"*"，则执行jiao方法 

elseif(ope.equals("*")){

m=c.getMethod("jiao",args);
}

//如果操作符为"-"，则执行cha方法 

elseif(ope.equals("-")){

m=c.getMethod("cha",args);

}else{

System.out.println("NoSuchMethod");

returnnull;
}

return(Type)m.invoke(obj,newObject[]{arg});
}

/**
*读入用户输入的匹配规则如：((C+B)*A)-B
*
*@return

*/

privateStackreadInput(){

Stackret=newStack();

Stringstr=null;

Stringo=null;

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

try{
str=br.readLine();

}catch(IOExceptione){
e.printStackTrace();

returnnull;
}

for(inti=str.length();i>0;i--){
o=str.substring(i-1,i);

//当遇到A,B,C时，生成Type对象存入栈中 

if(o.matches("[ABC]")){
ret.push(typeFactory(o));

continue;
}
ret.push(o);
}

returnret;
}

/**
*构造工厂根据传入的type构造Type对象保存住原集合
*
*@paramtype
*@return

*/

privateTypetypeFactory(Stringtype){

if(type.equals("A")){

returnnewType(typeA.getArray());

}elseif(type.equals("B")){

returnnewType(typeB.getArray());

}elseif(type.equals("C")){

returnnewType(typeC.getArray());

}else{

returnnull;
}
}

/**
*把如{13,2,1,20,30,50}的集合抽象成一个类，提供并、交、差操作
*
*@authorbzwm
*

*/

classType{

//保存数据集合的List 

privateListarray=newArrayList();

publicType(Stringsrt){

this.array=createList(srt);
}

publicType(Listlist){

this.array.addAll(list);
}

publicListgetArray(){

returnthis.array;
}

/**
*并操作
*
*@paramarg
*@return

*/

publicTypebing(Typearg){

//是否加入到集合中的标志 

booleanadd=true;

//取出传入的Type对象的List 
Listlist=arg.getArray();

//遍历传入的Type对象的List 

for(inti=0;i<list.size();i++){

add=true;

//与array里的值一一进行比较，如果全都不等，则加入到原array中，否则不加入 

for(intj=0;j<array.size();j++){

if(((Integer)list.get(i)).intValue()==((Integer)array

.get(j)).intValue()){

add=false;
}
}

if(add){

array.add(list.get(i));
}
}

//返回新的Type对象 

returnnewType(array);
}

/**
*交操作
*
*@paramarg
*@return

*/

publicTypejiao(Typearg){

//是否加入到集合中的标志 

booleanadd=false;

//存放交集数据的List 

Listret=newArrayList();

//取出传入的Type对象的List 
Listlist=arg.getArray();

//遍历传入的Type对象的List 

for(inti=0;i<list.size();i++){

add=false;

//与array里的值一一进行比较，如果有相等的，则加入到ret中，否则不加入 

for(intj=0;j<array.size();j++){

if(((Integer)list.get(i)).intValue()==((Integer)array

.get(j)).intValue()){

add=true;
}
}

if(add){

ret.add(list.get(i));
}
}

//返回新的Type对象 

returnnewType(ret);
}

/**
*差操作
*
*@paramarg
*@return

*/

publicTypecha(Typearg){

//是否加入到集合中的标志 

booleanadd=true;

//存放交集数据的List 
Listlist=arg.getArray();

//遍历传入的Type对象的List 

for(inti=0;i<list.size();i++){

add=true;

//与array里的值一一进行比较，如果有相等的，则从原array中将其删除，如果全都不等，则加入到原array中 

for(intj=0;j<array.size();j++){

if(((Integer)list.get(i)).intValue()==((Integer)array

.get(j)).intValue()){

add=false;

//删除相等的数据 
array.remove(j);
}
}

if(add){

array.add(list.get(i));
}
}

//返回新的Type对象 

returnnewType(array);
}

/**
*解析字符串，将数字加入到List中
*
*@paramstr
*@return

*/

privateListcreateList(Stringstr){

//将字符串解析成字符串数组A{13,2,1,20,30,50}-->newString[]{13,2,1,20,30,50} 

Strings[]=str.replaceAll(str.substring(0,1),"").replace("{",

"").replace("}","").split(",");

Listlist=newArrayList();

for(inti=0;i<s.length;i++){

list.add(newInteger(s[i]));
}

returnlist;
}
}

/**
*测试程序
*
*@paramargs
*@throwsInvocationTargetException
*@throwsIllegalAccessException
*@throwsNoSuchMethodException
*@throwsIllegalArgumentException
*@throwsSecurityException

*/

publicstaticvoidmain(Stringargs[])throwsSecurityException,
IllegalArgumentException,NoSuchMethodException,
IllegalAccessException,InvocationTargetException{

EditorStringV2es=newEditorStringV2("input.txt");
Stacks=es.readInput();

Stackresult=es.displayResult(s);//((C+B)*A)-B 
Listlist=((Type)result.pop()).getArray();

System.out.println("操作运算后结果为：");

for(inti=0;i<list.size();i++)

System.out.print(list.get(i)+"");
}
}