公式解析java版 高手指点，分不够等攒够了分另开贴

Question

Statement stmt = conn.createStatement(ResultSet.CURSOR_SCROLL_INSENSITIVE,ResultSet.CURSOR_UPDATABLE);
ResultSet rs = stmt.executeQuery(sql);
rs.last();
int count = rs.getRow();
rs.beforeFirst();

Answer 1

不好意思，发错地方了。 
sorry

Answer 2

就是怎么解析数学公式的程序，当然是java版本，。
说说公式解析的思路也可以！

Answer 3

主要就是操作符和数字的出栈入栈//:表达式解析-两栈算法.txt
//:Arithmetic.javapackage citi;
import java.util.Iterator;
import java.util.Stack;
import java.util.ArrayList;public class Arithmetic{
  //定义操作符，为简单起见，只涉及四则运算，可相应扩充之
  static String Operators="+-*/()#";
  //定义操作符的比较优先级，
  //其中1表示前面的操作符优于后面的操作符
  //   -1表示前面的操作符低于后面的操作符  
  //    0表示前面的操作符等于后面的操作符
  //    2表示前面的操作符不可能与后面的操作符相比较，如果碰到，则表达式有错  
  //PrecedeList[0][]表示+和+-*/()#这七个操作符相比较的优先级
  //PrecedeList[1][]表示-和+-*/()#这七个操作符相比较的优先级
  //以此类推
  static byte PrecedeList[][]={
                                { 1, 1,-1,-1,-1, 1, 1},
                                { 1, 1,-1,-1,-1, 1, 1},
                                { 1, 1, 1, 1,-1, 1, 1},
                                { 1, 1, 1, 1,-1, 1, 1},
                                {-1,-1,-1,-1,-1, 0, 2},
                                { 1, 1, 1, 1, 2, 1, 1},
                                {-1,-1,-1,-1,-1, 2, 0}};
  //定义数据中可能出现的数字和小数点，可以扩展
  static String Numbers="0123456789.";
  private Stack Operator,Operand;
  private ArrayList Expression;
  
  public Arithmetic(String inputStr){
   Operator=new Stack();
   Operator.push("#");
   Operand=new Stack();
   Expression=new ArrayList();
   Parse(inputStr);
  }
  //解析输入的表达式，将操作符和数据分开
  //如输入表达式2+3*(32-2)则解析成2 + 3 * ( 32 - 2 )这九个字符串
  private void Parse(String instr){
   String single;  
   int temp;
   String tempstr="#";
   for(int i=0;i<instr.length();i++){  
   single=instr.substring(i,i+1);
   //排除非操作符、数字的非法输入，如2+3m
   //Operators.indexOf(single)==6排除#
   if(Numbers.indexOf(single)<0 && (Operators.indexOf(single)<0 || Operators.indexOf(single)==6)){
   System.out.println("Input have wrong char:"+single);
   Expression.clear();
   return;
   }
   //获得前一个输入字符
   temp=Expression.size()-1;
   if(temp>-1){
   tempstr=(String)Expression.get(temp);
   }
   //排除连续两个操作符的情况，如3**2
   if(Operators.indexOf(single)>-1 && temp>-1 && Operators.indexOf(tempstr)>-1){
   System.out.println("Input have wrong format,two Operators are conjoint");
   Expression.clear();
   return;
   }  
   //如果当前字符是数字（包括.）而且前一字符也是数字，则将当前字符加到前一字符后面
   //其他情况均新添加一个元素
   if(Operators.indexOf(single)<0 && temp>-1 && Operators.indexOf(tempstr)<0){
   Expression.set(temp,tempstr+single);
   }  
   else{
     Expression.add(single);//其他情况均新添加一个元素
   }
   }  
   //为了算法处理方便起见，添加特殊字符＃
   Expression.add("#");   
  }
  
  //比较两个操作符的优先级
  private byte Precede(String firstOperator,String secondOperator){
   return PrecedeList[Operators.indexOf(firstOperator)][Operators.indexOf(secondOperator)];
  }  
  
  //对两个数据字符串进行运算
  private double Operate(String firstOperand,String Operator,String secondOperand){
   if(Operator.equals("+")){
   return (Double.parseDouble(firstOperand)+Double.parseDouble(secondOperand));
   }
   else if(Operator.equals("-")){
   return (Double.parseDouble(firstOperand)-Double.parseDouble(secondOperand));
   }
   else if(Operator.equals("*")){
   return (Double.parseDouble(firstOperand)*Double.parseDouble(secondOperand));
   }
   else if(Operator.equals("/")){
   return (Double.parseDouble(firstOperand)/Double.parseDouble(secondOperand));
   }
   else{
     System.out.println("Operator is wrong!Can throw a Exception");
     return 0;
    }
  }
  //采用两个栈对接解析后的表达式进行运算
  public double Compute(){
   if(Expression.isEmpty()){
   System.out.println("Expresion is empty");
   return 0;
   }
   Iterator it = Expression.iterator();
   String single;
   String firstOperand,secondOperand;
     
   single=(String)it.next();
   while(!(single.equals("#") && Operator.peek().equals("#"))){
   if(Operators.indexOf(single)<0){
   Operand.push(single);single=(String)it.next();
   }
   else{
     switch(Precede((String)Operator.peek(),single)){
      case -1:Operator.push(single);single=(String)it.next();break;
      case 0: Operator.pop();single=(String)it.next();break;
      case 1: 
              secondOperand=(String)Operand.pop();
              firstOperand=(String)Operand.pop();
              Operand.push(String.valueOf(Operate(firstOperand,(String)Operator.pop(),secondOperand)));break;
      case 2: System.out.println("Expression is wrong!Can throw a Exception");break;
     }
     }
   }  
    return Double.parseDouble((String)Operand.pop());
  }
  
  public static void main(String[] args){
   long t1 = System.currentTimeMillis();    
     
   Arithmetic t=new Arithmetic(args[0]);
   System.out.println(t.Compute());  
  
   long t2 = System.currentTimeMillis();
    System.out.println("Time needed: " + (t2 - t1));
  }
}

Answer 4

还不如调用Script引擎，使用Script中的eval。

Answer 5

alaal(穷街) 
的算法不错，但是有点结构化语言的味道！
谁能用面向对象的思想写出来。楼主的分不够，我开帖送分

Answer 6

to:meconsea(罂粟(mecon)) 
　　我强烈支持你的提议，不过只能声援了

Answer 7

我着有个老外的例子，你mail是多少？

Answer 8

[email protected]
谢谢 !

Answer 9

用开源项目bean shell，万事ok：http://www.beanshell.orgexample:import bsh.*;Object obj = new Interpreter().eval("400 > 300");if ( obj.toString().equalsIgnoreCase("true") )
{
    // do something...
}

Answer 10

to:meconsea(罂粟(mecon)) 
　　支持你的提议，不过这个用javacc语法解析器来写面向对象的解析代码，还好的！我也在研究这个！呵呵

Answer 11

up!
bean shell 怎么用?

Answer 12

就是动态运行java代码。要是闲java语法麻烦，就用javascript的动态运行器。http://www.mozilla.org/rhino/

Answer 13

例子我已经给了。如果你知道javascript的eval函数的作用，应该能触类旁通。再写多点：import bsh.*;Interpreter itp = new Interpreter();// 你在数据库中字段c储存了公式如下
// a > b
// a,b分别是字段名, number类型String code = 
  "\n    int a = " + rs.getInt("a")
+ "\n    int b = " + rs.getInt("b")
+ "\n    return " + rs.getString("c");// 运行上面的java语句，返回结果并判断
if ( itp.eval(code).toString().equalsIgnoreCase("true") ) // a > b
{
    
}

Answer 14

http://www.china-pub.com/computers/ebook20001-25000/21497/ch02.rar