设计模式 之 解释器模式

好多的  加法运算 ，没有发现  加括号的 的加减乘除的 解释器，参考了 别人的 算法，写了 这个 ，只能说别人的算法好，，，，

算法地址： http://blog.sina.com.cn/s/blog_6759f4610100j2qt.html

package 设计模式.解释器模式;  import java.util.HashMap; import java.util.Map;  public class Context {  private final Map<String, Integer> valueMap = new HashMap<String, Integer>();   public void addValue(final String key, final int value) {   valueMap.put(key, Integer.valueOf(value));  }   public int getValue(final String key) {   return valueMap.get(key).intValue();  } }

package 设计模式.解释器模式;  public abstract class AbstractExpression {   public abstract int interpreter(Context context); }

package 设计模式.解释器模式;  public class TerminalExpression extends AbstractExpression {  private final int i;   public TerminalExpression(final int i) {   this.i = i;  }   @Override  public int interpreter(final Context context) {   return this.i;  }  }

package 设计模式.解释器模式;  public class AddNonterminalExpression extends AbstractExpression {  private final AbstractExpression left;  private final AbstractExpression right;   public AddNonterminalExpression(final AbstractExpression left,    final AbstractExpression right) {   this.left = left;   this.right = right;  }   @Override  public int interpreter(final Context context) {   return this.left.interpreter(context) + this.right.interpreter(context);  }  }

package 设计模式.解释器模式;  public class SubtractNonterminalExpression extends AbstractExpression {  private final AbstractExpression left;  private final AbstractExpression right;   public SubtractNonterminalExpression(final AbstractExpression left,    final AbstractExpression right) {   this.left = left;   this.right = right;  }   @Override  public int interpreter(final Context context) {   return this.left.interpreter(context) - this.right.interpreter(context);  } }

package 设计模式.解释器模式;  public class MultiplyNonterminalExpression extends AbstractExpression {  private final AbstractExpression left;  private final AbstractExpression right;   public MultiplyNonterminalExpression(final AbstractExpression left,    final AbstractExpression right) {   this.left = left;   this.right = right;  }   @Override  public int interpreter(final Context context) {   return this.left.interpreter(context) * this.right.interpreter(context);  }  }

package 设计模式.解释器模式;  public class DivisionNonterminalExpression extends AbstractExpression {  private final AbstractExpression left;  private final AbstractExpression right;   public DivisionNonterminalExpression(final AbstractExpression left,    final AbstractExpression right) {   this.left = left;   this.right = right;  }   @Override  public int interpreter(final Context context) {   final int value = this.right.interpreter(context);   if (value != 0) {    return this.left.interpreter(context) / value;   }   return -1111;  } }

package 设计模式.解释器模式;   //解释器模式定义语言的文法，并且建立一个解释器来解释该语言中的句子。它属于类的行为模式。这里的语言意思是使用规定格式和语法的代码。 //应用环境： //如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。 //这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。而且当文法简单、效率不是关键问题的时候效果最好。 public class InterpreterDemo {  // 40~47  ( ) * + , - . /      0~9 是 48~57 a~z 是 97~122 A~Z 是 65~90     61 =  // ( a+ b * ( a + b ) * a ) * b + a    // [1, +, 2, *, (, 3, +, 4, *, 5, ), *, 1, #]    class NumQueue {  char num[];  int head, rear;   NumQueue() {   num = new char[1];   head = -1;   rear = -1;  }   public boolean isEmpty() {   if (head == rear)    return true;   else    return false;  }   public void inQueue(char ch) {   num[++rear] = ch;  }   public void init() {   head = -1;   rear = -1;   for (int i = 0; i < 1; i++)    num[i] = '/0';  }   public String getNumber() {   String str = new String(num);    return str;  } }   class StackAbstractExpression {  AbstractExpression data[];  int top;  int base;   StackAbstractExpression() {   data = new AbstractExpression[15];   top = -1;   base = -1;  }   public AbstractExpression getTop() {   return data[top];  }   public void push(AbstractExpression ae) {   data[++top] = ae;  }   public AbstractExpression pop() {   return data[top--];  }   public boolean isEmpty() {   if (top == base)    return true;   else    return false;  }   public void init() {   top = -1;   base = -1;  } }  class StackOper {  char data[];  int top;  int base;   StackOper() {   data = new char[20];   top = -1;   base = -1;  }   public char getTop() {   return data[top];  }   public void init() {   top = -1;   base = -1;  }   public void push(char ch) {   data[++top] = ch;  }   public char pop() {   return data[top--];  }   public boolean isEmpty() {   if (top == base)    return true;   else    return false;  } }       static StackAbstractExpression stackData;  static StackOper stackOper;  static NumQueue queue;  static boolean  rs, divErr = false;  public static void   doHandler(String exp, Context context){   queue = new InterpreterDemo().new NumQueue();    stackData =  new InterpreterDemo().new StackAbstractExpression();   stackOper =  new InterpreterDemo().new StackOper();   exp = exp.replaceAll(" ","");   exp+= "#";   stackOper.init();   stackData.init();   stackOper.push('#');   String dou = "";   int ps = 0, pc = 0;    System.out.println(" exp: "+exp);      char ch[] = exp.toCharArray();    char op;   int i = 0;   op = ch[i];    while (op != '#' || stackOper.getTop() != '#') {    if ((op > 96 && op < 123) ) {     queue.inQueue(op);     i++;     op = ch[i];    } else {     if (!queue.isEmpty()) {      dou = queue.getNumber();      //System.out.println ("stackData.push  (" + dou + ") ");      stackData.push(new TerminalExpression(context.getValue(dou)));      queue.init();     }     ps = getSPri(stackOper.getTop());     pc = getCPri(op);     if (stackOper.getTop() == '(' && op == '#'       || stackOper.getTop() == ')' && op == '('       || stackOper.getTop() == '#' && op == ')') {       rs = true;     }     if (ps < pc) {      //System.out.println (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc +" "+ "stackOper.push  " + op + " ");      stackOper.push(op);      i++;      op = ch[i];     }     if (ps == pc) {      char c = stackOper.pop();      //System.out.println  (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc + "stackOper.pop  " + c + " ");      op = ch[++i];     }     if (ps > pc) {      char theta = stackOper.pop();      AbstractExpression b =   stackData.pop();      AbstractExpression a =  stackData.pop();      stackData.push(operate(a, b, theta));      //System.out.println  (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc +" stackData.push  "  +operate(a, b, theta)+ " ");     }    }   }   double res = stackData.getTop().interpreter(context);   System.out.println(res);   rs = true;    }    public static AbstractExpression operate(AbstractExpression a, AbstractExpression b, char ch) {   AbstractExpression res =null;   switch (ch) {   case '+':    res = new AddNonterminalExpression( a, b);    break;   case '-':    res = new SubtractNonterminalExpression( a, b);    break;   case '*':    res = new MultiplyNonterminalExpression( a, b);    break;   case '/':    res = new DivisionNonterminalExpression( a, b);     break;    default:     break;   }   return res;  }    // 操作符在栈内的优先级  public static int getSPri(char op) {   int pr = 0;   switch (op) {   case ')':    pr = 6;    break;   case '*':    pr = 5;    break;   case '/':    pr = 5;    break;   case '+':    pr = 3;    break;   case '-':    pr = 3;    break;   case '(':    pr = 1;    break;   case '#':    pr = 0;    break;   }   return pr;  }   // 操作符进栈的优先级优先级  public static int getCPri(char op) {   int pr = 0;   switch (op) {   case ')':    pr = 1;    break;   case '*':    pr = 4;    break;   case '/':    pr = 4;    break;   case '+':    pr = 2;    break;   case '-':    pr = 2;    break;   case '(':    pr = 6;    break;   case '#':    pr = 0;    break;   }   return pr;  }      public static void main(String[] args) {   final Context context = new Context();   context.addValue("a", 1);   context.addValue("b", 2);    doHandler("(a+b*(a+b)*a)*b+a",context);  } }