1 package test;
  2
  3 import java.util.LinkedList;
  4 import java.util.Scanner;
  5
  6 import javax.naming.InitialContext;
  7
  8 /*
  9  * 基于"算符优先"文法 的表达式求值， 其实这也是数据程序编译器设计中常用的一种方法
 10  * 其实可以一次性 扫描中缀表达式的同时，利用算符文法来求出中缀表达式的值，由于中缀式和后缀式的相互转化使用的也是算法文法，这里就把问题分开两部分来做
 11  * 提前说一下，个人总是感觉，算法设计类的问题总是比较适合面向过程来解决，这里硬是面向对象感觉有点伪面向对象的感觉
 12  * ExpressionEvaluate    算法的主体驱动部分
 13  */
 14
 15 public class ExpressionEvaluate {
 16
 17     public static final String OP = "+-*/()#";    //求值系统的所有算附表
 18     public static final int[][] opPreTable={    //算符优先级表
 19         {1, 1, -1, -1, -1, 1, 1},
 20         {1, 1, -1, -1, -1, 1, 1},
 21         {1, 1, 1, 1, -1, 1, 1},
 22         {1, 1, 1, 1, -1, 1, 1},
 23         {-1, -1, -1, -1, -1, 0, Integer.MAX_VALUE},
 24         {1, 1, 1, 1, Integer.MAX_VALUE, 1, 1},
 25         {-1, -1, -1, -1, -1, -Integer.MAX_VALUE, 0}
 26     };
 27
 28     // 定义两个工作栈
 29     private LinkedList<Character> optr;    // 存储操作符
 30     private LinkedList<? super Number> opnd;    //存储数字
 31     private StringBuffer inffixExp;        //    存储中缀表达式
 32     private StringBuffer suffixExp;        //存储后缀表达式
 33     private double result;                //表达式最终的结果
 34
 35     {// 构造代码块 优先于 构造函数的执行
 36         init();    //初始化操作
 37     }
 38     public ExpressionEvaluate() {
 39
 40     }
 41     public ExpressionEvaluate(String exp)
 42     {
 43         setInffixExp(exp);
 44     }
 45
 46     public void setInffixExp (String exp)
 47     {
 48         inffixExp = new StringBuffer(exp);
 49         if(inffixExp.charAt(inffixExp.length()-1)!='#')
 50             inffixExp.append('#');
 51     }
 52
 53     private void init()
 54     {
 55         inffixExp = new StringBuffer();
 56         suffixExp = new StringBuffer();
 57         optr = new LinkedList<Character>();
 58         opnd = new LinkedList<Number>();
 59         optr.push('#');
 60         result = 0;
 61     }
 62
 63     public String getInffix()
 64     {
 65         return new String(inffixExp.substring(0, inffixExp.length()-1));
 66     }
 67     public String getSuffix()
 68     {
 69         return new String(suffixExp);
 70     }
 71     public Double getResult()
 72     {
 73         return result;
 74     }
 75
 76     /*
 77      * 中缀表达式的 求值计算
 78      */
 79     public void inffixCal()
 80     {
 81         int index = 0;
 82
 83         while(inffixExp.charAt(index)!='#' || optr.peekFirst()!='#')
 84         {
 85             Character ch = inffixExp.charAt(index);
 86             if(!inOP(ch))
 87             {// 一般数字
 88                 opnd.push(Double.parseDouble(ch+""));    //于是准备取下一个字符了
 89                 index ++;
 90             }
 91             else{// 运算符
 92                 switch(Precede(optr.peekFirst(), ch))
 93                 {
 94                     case -1:    // < 栈顶 符号 的优先级 低 符号入栈
 95                         optr.push(ch);
 96                         index ++;
 97                         break;
 98
 99                     case 1:        // > 即栈顶符号的优先级比较高
100                         Character theta = optr.pop();
101                         Number b = (Double) opnd.pop();
102                         Number a = (Double) opnd.pop();
103                         Double c = operate(a, b, theta);
104                         opnd.push(c);        // 把计算的结果再次压站
105                         break;
106
107                     case 0:    // 两种运算符的优先级相等 也就是 ()
108                         optr.pop();    //脱括号之后 接着往后扫描
109                         index ++;
110                         break;
111                     default:
112                         throw new RuntimeException(new Exception("您的文法有误，请检查"));
113                 }
114             }
115         }
116         result = (Double)opnd.pop();
117     }
118
119     public double operate(Number a, Number b, Character theta) {
120         double c = 0;
121         switch(theta)
122         {
123             case '+':
124                 c = (Double)a + (Double)b;
125                 break;
126             case '-':
127                 c = (Double)a - (Double)b;
128                 break;
129             case '*':
130                 c = (Double)a * (Double)b;
131                 break;
132             case '/':
133                 if((Double)b == 0)
134                     throw new RuntimeException(new Exception("除数不能为0"));
135                 c = (Double)a / (Double)b;
136                 break;
137             default:
138                 throw new RuntimeException(new Exception("尚不支持这种运算"));
139         }
140         return c;
141     }
142     /*
143      * 比较栈optr栈顶符号 和 当前符号之间的优先级
144      */
145     public int Precede(Character peekFirst, Character ch) {
146         return opPreTable[OP.indexOf(peekFirst)][OP.indexOf(ch)];
147     }
148     // 判断某个字符是不是在 运算符表中
149     public boolean inOP(Character ch)
150     {
151         return OP.contains(new String (ch+""));
152     }
153
154     /*
155      * 中缀表达式到后缀表达式
156      * 和 中缀式 求值 非常相似
157      */
158     public void inffix2suffix()
159     {
160         suffixExp.setLength(0);
161         optr.clear();
162         opnd.clear();
163         int index = 0;
164
165     }
166
167     public static void main(String[] args) {
168 /*        String exp;
169         Scanner scanner = new Scanner(System.in);    // 2*(5-1)/2+3-1
170
171         System.out.println("输入一个以#结尾的表达式");
172         exp = scanner.next();*/
173
174         ExpressionEvaluate ee = new ExpressionEvaluate();
175         ee.setInffixExp("2*3*4-1#");
176
177         System.out.println(ee.getInffix());
178
179         ee.inffixCal();
180
181         System.out.println(ee.getResult());
182
183
184     }
185
186 }