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);
  }
}

这种方式使用js的方式进行运算，使用较简单，但是当运算double类型的四则运算时结果会出现循环小数,运算结果会出现问题.

方式二(能够保证四则运算精度):

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;

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 expList = new ArrayList();
 //存放逆波兰表达式
 private List rpnList = new ArrayList();
 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);
 }
 
 public String getExpbase() {
  return expbase;
 }
 
 public void setExpbase(String expbase) {
  this.expbase = expbase;
 }
 
 public String getExpInited() {
  return expInited;
 }
 
 public void setExpInited(String expInited) {
  this.expInited = expInited;
 }
 
 public int getPrecision() {
  return precision;
 }
 
 public void setPrecision(int precision) {
  this.precision = precision;
 }
 
 public RoundingMode getRoundingMode() {
  return roundingMode;
 }
 
 public void setRoundingMode(RoundingMode roundingMode) {
  this.roundingMode = roundingMode;
 }
 
 public List getExpList() {
  return expList;
 }
 
 public void setExpList(List expList) {
  this.expList = expList;
 }
 
 public List getRpnList() {
  return rpnList;
 }
 
 public void setRpnList(List rpnList) {
  this.rpnList = rpnList;
 }
 
 public MathContext getMc() {
  return mc;
 }
 
 public void setMc(MathContext mc) {
  this.mc = mc;
 }
 
 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;
 }
 
 private boolean isNumber(String str){
  Pattern p = Pattern.compile("^(-?\d+)(\.\d+)?$");
  Matcher m = p.matcher(str);
  boolean isNumber = m.matches();
  return isNumber;
 }
 
 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;
  }
 }
 
 public List initRPN(List strList){
  List returnList = new ArrayList();
  //用来存放操作符的栈
  Stack stack = new Stack();
//  stack.push(LOWESTSING);
  int length = strList.size();
  for(int i=0;i=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;
 }
 
 public String caculate(List rpnList){
  Stack numberStack = new Stack(); 
  int length=rpnList.size(); 
  for(int i=0;i=")&&-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 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 stackList = new linkedList();
  public Stack() {
  }
  
  public void push(String expression) {
   stackList.addLast(expression);
  }
  
  public String pop() {
   return stackList.removeLast();
  }
  
  public String top() {
   return stackList.getLast();
  }
  
  public boolean isEmpty() {
   return stackList.isEmpty();
  }
 }
}

以上这篇java代码执行字符串中的逻辑运算方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持考高分网。