java代码执行字符串中的逻辑运算方法

public class test
{
 public static void main(string[] args) throws exception {
   string str = "(a or b) and c";
   str = str.replaceall("or", "||");
   str = str.replaceall("and", "&&");
   system.out.println(str);
   scriptenginemanager manager = new scriptenginemanager();
   scriptengine engine = manager.getenginebyname("js");
   engine.put("a",true);
   engine.put("b",false);
   engine.put("c",true);  
   object result = engine.eval_r(str);
   system.out.println("结果类型:" + result.getclass().getname() + ",计算结果:" + result);
  }
}

/**
 * @project:  bizrule  
 * @file:   org.coffeesweet.util.mathexpress.java
 * @author:  coffeesweet
 * @date:   2011-3-28
 * @description: 2011 coffeesweet inc. all rights reserved.
 */
package org.coffeesweet.util;
import java.math.bigdecimal;
import java.math.mathcontext;
import java.math.roundingmode;
import java.util.arraylist;
import java.util.linkedlist;
import java.util.list;
import java.util.stringtokenizer;
import java.util.regex.matcher;
import java.util.regex.pattern;
/**
 * @author coffeesweet
 * +,-,*,/四则运算的表达式逆波兰解析计算类,精确计算,应用bigdecimal类处理
 * 支持负数,但规范除整个表达式第一个数为负数时可以不出现在'('后，其它表达式中间任何位置的
 * 负数必须出现在'('后,即：用括号括起来。比如：-3+(-2+1)*10或-3+((-2)+1)*10或(-3)+(-2+1)*10或(-3)+((-2)+1)*10
 */
public class mathexpress {
 /**
  * +
  */
 private final static string op1 = "+";
 /**
  * -
  */
 private final static string op2 = "-";
 /**
  * *
  */
 private final static string op3 = "*";
 /**
  * /
  */
 private final static string op4 = "/";
 /**
  * ^
  */
// private final static string op5 = "^";
 /**
  * %
  */
// private final static string op6 = "%";
 /**
  * (
  */
 private final static string opstart = "(";
 /**
  * )
  */
 private final static string opend = ")";
 /**
  * !用来替代负数前面的'-'
  */
// private final static string negativesing = "!";
 /**
  * !用来替代负数前面的'+'
  */
// private final static string plussing = "@";
 /**
  * '#'用来代表运算级别最低的特殊字符
  */
// private final static string lowestsing = "#";
 //最原始的四则运算式
 private string expbase;
 //经过初始化处理后的四则运算式
 private string expinited;
 //精度
 private int precision=10;
 //取舍模式
 private roundingmode roundingmode=roundingmode.half_up;
 //精度上下文
 private mathcontext mc;
 //四则运算解析
 private list<string> explist = new arraylist<string>();
 //存放逆波兰表达式
 private list<string> rpnlist = new arraylist<string>();
 public mathexpress(){
 }
 public mathexpress(string expbase) {
  init(expbase,this.precision,this.roundingmode);
 }
 public mathexpress(string expbase,int precision,roundingmode roundingmode){
  init(expbase,precision,roundingmode);
 }
 public void init(string expbase,int precision,roundingmode roundingmode){
  this.expbase = expbase;
  this.precision = precision;
  this.roundingmode = roundingmode;
  this.mc = new mathcontext(precision,roundingmode);
  this.expinited = initexpress(expbase);
  stringtokenizer st = new stringtokenizer(this.expinited,"+-*/^%()",true);
  while(st.hasmoreelements()){
   this.explist.add(st.nextelement().tostring().trim());
  }
  this.rpnlist = initrpn(this.explist);
 }
 /**
  * @return the expbase
  */
 public string getexpbase() {
  return expbase;
 }
 /**
  * @param expbase the expbase to set
  */
 public void setexpbase(string expbase) {
  this.expbase = expbase;
 }
 /**
  * @return the expinited
  */
 public string getexpinited() {
  return expinited;
 }
 /**
  * @param expinited the expinited to set
  */
 public void setexpinited(string expinited) {
  this.expinited = expinited;
 }
 /**
  * @return the precision
  */
 public int getprecision() {
  return precision;
 }
 /**
  * @param precision the precision to set
  */
 public void setprecision(int precision) {
  this.precision = precision;
 }
 /**
  * @return the roundingmode
  */
 public roundingmode getroundingmode() {
  return roundingmode;
 }
 /**
  * @param roundingmode the roundingmode to set
  */
 public void setroundingmode(roundingmode roundingmode) {
  this.roundingmode = roundingmode;
 }
 /**
  * @return the explist
  */
 public list<string> getexplist() {
  return explist;
 }
 /**
  * @param explist the explist to set
  */
 public void setexplist(list<string> explist) {
  this.explist = explist;
 }
 /**
  * @return the rpnlist
  */
 public list<string> getrpnlist() {
  return rpnlist;
 }
 /**
  * @param rpnlist the rpnlist to set
  */
 public void setrpnlist(list<string> rpnlist) {
  this.rpnlist = rpnlist;
 }
 /**
  * @return the mc
  */
 public mathcontext getmc() {
  return mc;
 }
 /**
  * @param mc the mc to set
  */
 public void setmc(mathcontext mc) {
  this.mc = mc;
 }
 /**
  * 去除空白字符和在负号'-'前加'0',便于后面的stringtokenizer
  * @param exp
  * @return
  */
 private static string initexpress(string exp){
  string restr = null;
  restr = exp.replaceall("\\s", "");
  if(restr.startswith("-")){
   restr = "0"+restr;
  }
  restr = restr.replaceall("\\(\\-", "(0-");
  return restr;
 }
 /**
  * 是否是整数或是浮点数,但默认-05.15这种也认为是正确的格式
  * @param str
  * @return
  */
 private boolean isnumber(string str){
  pattern p = pattern.compile("^(-?\\d+)(\\.\\d+)?$");
  matcher m = p.matcher(str);
  boolean isnumber = m.matches();
  return isnumber;
 }
 /**
  * 设置优先级顺序()设置与否无所谓
  * @param sign
  * @return
  */
 private int precedence(string str){
  char sign = str.charat(0);
  switch(sign){
   case '+':
   case '-':
    return 1;
   case '*':
   case '/':
    return 2;
   case '^':
   case '%':
    return 3;
   case '(':
   case ')':
//   case '#':
   default:
    return 0;
  }
 }
 /**
  * 转变为逆波兰表达式
  * @param strlist
  * @return
  */
 public list<string> initrpn(list<string> strlist){
  list<string> returnlist = new arraylist<string>();
  //用来存放操作符的栈
  stack stack = new stack();
//  stack.push(lowestsing);
  int length = strlist.size();
  for(int i=0;i<length;i++ ){
   string str = strlist.get(i);
   if(isnumber(str)){
    returnlist.add(str);
   }else{
    if(str.equals(opstart)){
     //'('直接入栈
     stack.push(str);
    }else if(str.equals(opend)){
     //')'
     //进行出栈操作，直到栈为空或者遇到第一个左括号 
     while (!stack.isempty()) { 
      //将栈顶字符串做出栈操作 
      string tempc = stack.pop(); 
      if (!tempc.equals(opstart)) { 
       //如果不是左括号，则将字符串直接放到逆波兰链表的最后 
       returnlist.add(tempc); 
      }else{ 
       //如果是左括号，退出循环操作 
       break; 
      } 
     } 
    }else{
     if (stack.isempty()) {
      //如果栈内为空 
      //将当前字符串直接压栈 
      stack.push(str); 
     }else{
      //栈不空,比较运算符优先级顺序
      if(precedence(stack.top())>=precedence(str)){
       //如果栈顶元素优先级大于当前元素优先级则
       while(!stack.isempty() && precedence(stack.top())>=precedence(str)){
        returnlist.add(stack.pop());
       }
      }
      stack.push(str);
     }
    }
   }
  }
  //如果栈不为空，则将栈中所有元素出栈放到逆波兰链表的最后 
  while (!stack.isempty()) {
   returnlist.add(stack.pop());
  }
  return returnlist;
 }
 /**
  * 计算逆波兰表达式
  * @param rpnlist
  * @return
  */
 public string caculate(list<string> rpnlist){
  stack numberstack = new stack(); 
  int length=rpnlist.size(); 
  for(int i=0;i<length;i++){ 
   string temp=rpnlist.get(i); 
   if(isnumber(temp)){ 
    numberstack.push(temp); 
   }else{ 
    bigdecimal tempnumber1 = new bigdecimal(numberstack.pop(),this.mc);
    bigdecimal tempnumber2 = new bigdecimal(numberstack.pop(),this.mc);
    bigdecimal tempnumber = new bigdecimal("0",this.mc);
    if(temp.equals(op1)){ 
     tempnumber=tempnumber2.add(tempnumber1); 
    }else if(temp.equals(op2)){ 
     tempnumber=tempnumber2.subtract(tempnumber1); 
    }else if(temp.equals(op3)){ 
     tempnumber=tempnumber2.multiply(tempnumber1); 
    }else if(temp.equals(op4)){ 
     tempnumber=tempnumber2.divide(tempnumber1, 
       precision, 
       roundingmode); 
    } 
    numberstack.push(tempnumber.tostring()); 
   } 
  } 
  return numberstack.pop();
 }
 /**
  * 按照类的缺省参数进行计算
  * @return
  */
 public string caculate(){
  return caculate(this.rpnlist);
 }
 /**
  * 数字条件表达式精确比较
  * eg: "3.0>2" "1<5" "1==5" "1!=5" "(1.0+2)>3" "((-0.9+3)>=2. 1)"
  * 不支持&&,||等连接符
  * @param str
  * @return
  */
 public static boolean compareto(string strparm){
  boolean reboolean = false;
  boolean isparentheses = false;//标记是否有()括上整个字符串
  string str = initexpress(strparm);
  pattern p = pattern.compile("^\\([\\s\\s]*\\)$");
  matcher m = p.matcher(str);
  isparentheses = m.matches();
  if(-1==str.indexof(">=")&&-1==str.indexof("<=")&&-1==str.indexof("==")&&-1==str.indexof("!=")){
   if(-1==str.indexof(">")&&-1==str.indexof("<"))
   throw new illegalargumentexception("异常:条件表达式不正确!");
  }
  if(-1 != str.indexof(">=")){
   string[] strtemps = str.split(">=");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( -1 == r ){
    reboolean = false;
   }else{
    reboolean = true;
   }
  }else if(-1 != str.indexof("<=")){
   string[] strtemps = str.split("<=");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( 1 == r ){
    reboolean = false;
   }else{
    reboolean = true;
   }
  }else if(-1 != str.indexof("==")){
   string[] strtemps = str.split("==");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( 0 == r ){
    reboolean = true;
   }else{
    reboolean = false;
   }
  }else if(-1 != str.indexof("!=")){
   string[] strtemps = str.split("!=");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( 0 != r ){
    reboolean = true;
   }else{
    reboolean = false;
   }
  }else if((-1 != str.indexof(">")) && (-1 == str.indexof("="))){
   string[] strtemps = str.split(">");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( 1 == r ){
    reboolean = true;
   }else{
    reboolean = false;
   }
  }else if((-1 != str.indexof("<")) && (-1 == str.indexof("="))){
   string[] strtemps = str.split("<");
   if(isparentheses){
    strtemps[0] = strtemps[0] + ")";
    strtemps[1] = "(" + strtemps[1];
   }
   int r = new bigdecimal((new mathexpress(strtemps[0]).caculate())).compareto(new bigdecimal((new mathexpress(strtemps[1]).caculate())));
   if( -1 == r ){
    reboolean = true;
   }else{
    reboolean = false;
   }
  }
  return reboolean;
 }
 public static void main(string...args){
//  mathexpress me = new mathexpress("-(-0.5+0.1)*10+2",10,roundingmode.half_up);
//  system.out.println(me.getexplist());
//  list<string> templist = me.initrpn(me.getexplist());
//  system.out.println(templist);
//  string resultstr = me.caculate(templist);
//  system.out.println(resultstr);
  mathexpress me = new mathexpress("-(-1.5000000003+0.1)*10+2");
  string resultstr = me.caculate();
  bigdecimal bd = new bigdecimal(resultstr);
  bigdecimal bd2 = bd.setscale(2, roundingmode.half_up);
  system.out.println(me.caculate());
  system.out.println(bd.tostring());
  system.out.println(bd.scale());
  system.out.println(bd2.tostring());
  system.out.println(bd2.scale());
//  system.out.println("------------------------------------");
//  pattern p = pattern.compile("^\\([\\s\\s]*\\)$");//匹配类似以'('开头')'结尾的字符串
//  matcher m = p.matcher("(2. 0>2.22)");
//  system.out.println(m.matches());
  boolean reboolean = mathexpress.compareto("((-8.0+3)>=2. 1)");
  system.out.println(reboolean);
 }
 /**
  * 栈
  */
 private class stack {
  linkedlist<string> stacklist = new linkedlist<string>();
  public stack() {
  }
  /**
   * 入栈
   * @param expression
   */
  public void push(string expression) {
   stacklist.addlast(expression);
  }
  /**
   * 出栈
   * @return
   */
  public string pop() {
   return stacklist.removelast();
  }
  /**
   * 栈顶元素
   * @return
   */
  public string top() {
   return stacklist.getlast();
  }
  /**
   * 栈是否为空
   * @return
   */
  public boolean isempty() {
   return stacklist.isempty();
  }
 }
}