java字符串数学公式运算

转载 2012年03月27日 17:18:53
//由于网络限制禁止上传,因此在此提供源码,jar自己进行制作
/**
  pulbic static void main(String[]args){
     RunStringReg.cacComplex("1+1*2+(10-(2*(5-3)*(2-1))-4)+10/(5-0)");
  }
  思路整理:
  1.判断表达式中是否存在括号,如果存在,则提取括号中的表达式,进行计算(见步骤2),计算结束后,再次执行步骤1;如果不存在则直接执行步骤2.
  2.判断是否有乘除运算,如果有,则先执行乘除运算,执行完毕后再次执行步骤2;如果不存在则直接执行加减运算返回结果。
   参考: sghitxia
**/

ProgramService.java

package com.goma.runstringregex;

import java.math.BigDecimal;
/**
* DESC:采用BigDecimal进行运算的简单封装<BR>
* @author Goma(OMA1989@YEAH.NET)
*
*/
public class ProgramService
{
    /**
     * param:String
     * 将Null转为Zero
     * @return "0"
     */
    private String null2zero(String str)
    {
        if (str == null || "".equals(str))
        {
            str = "0";
        }
        return str;
    }

    /**
     * 提供精确的加法运算
     * @param v1 被加
     * @param v2 加数
     * @return 两个参数的和
     */
    public String add(String v1, String v2)
    {
        v1 = null2zero(v1);
        v2 = null2zero(v2);
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).toString();
    }

    /**
     * 提供精确的加法运算
     * @param params 
     * @return 两个参数的和
     */
    public String add2(String[] params)
    {
        String v0 = null2zero(params[0]);
        BigDecimal b0 = new BigDecimal(v0);
        for (int i = 1; i < params.length; i++)
        {
            String v1 = null2zero(params[i]);
            b0 = b0.add(new BigDecimal(v1));
        }
        return b0.toString();
    }

    /**
     * 提供精确的减法运算
     * @param v1 被减
     * @param v2 减数
     * @return 两个参数的差
     */
    public String sub(String v1, String v2)
    {
        v1 = null2zero(v1);
        v2 = null2zero(v2);
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).toString();
    }

    /**
     * 提供精确的减法运算
     * @param params
     * @return 传入参数 下标为0,与其他参数的差
     */
    public String sub2(String[] params)
    {
        String v0 = null2zero(params[0]);
        BigDecimal b = new BigDecimal(v0);
        for (int i = 1; i < params.length; i++)
        {
            String v1 = null2zero(params[i]);
            b = b.subtract(new BigDecimal(v1));
        }
        return b.toString();
    }

    /**
     * 提供精确的乘法运算
     * @param v1 被乘
     * @param v2 乘数
     * @return 两个参数的积
     */
    public String mul(String v1, String v2)
    {
        v1 = null2zero(v1);
        v2 = null2zero(v2);
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

    /**
     * DESC:提供精确的乘法运算
     * @param params
     * @return 传入参数的积
     */
    public String mul2(String[] params)
    {
        String v0 = null2zero(params[0]);
        BigDecimal b1 = new BigDecimal(v0);
        for (int i = 1; i < params.length; i++)
        {
            String v1 = null2zero(params[i]);
            b1 = b1.multiply(new BigDecimal(v1));
        }
        return b1.toString();
    }

    /**
     * 提供(相对)精确的除法运算 当发生除不尽的情况时,由scale参数
     * 定精度,以后的数字四舍五入
     * @param v1 被除
     * @param v2 除数
     * @param scale 表示表示 精确到小数点以后几位
     * @return 两个参数的商
     */
    public String div(String v1, String v2, int scale)
    {
        if (scale < 0)
        {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        v1 = null2zero(v1);
        v2 = null2zero(v2);
        if ("0".equals(v2)||"0.00".equals(v2))
        {
            return "0";
        }
        else
        {
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
        }
    }

}



package com.goma.runstringregex;

/**
* DESC:字符串表达式计算<BR>
* @author Goma(OMA1989@YEAH.NET)<br>
*/
public class RunStringReg {
    private static ProgramService ps = new ProgramService();
/**
* DESC:判断表达式是否有括号,有括号,则先计算括号内的表达式,无则直接运算结果。
* @param str
* @return 运算结果
*/
public static String cacComplex(String str) {
if (str.equals(""))
return "0";
int has = str.indexOf("[");
int have = str.indexOf("{");
System.out.println("RUN BEFORE:"+str);
if(has!=-1||have!=-1){
str = str.replaceAll("[\\[\\{]", "(").replaceAll("[\\]\\}]", ")");//将字符串中的"{}"、"[]"替换成"()"
System.out.println("TURN '{,[':" + str);
}
int cl = str.lastIndexOf('(');//判断字符串中是否存在"("
if (cl == -1)
return cac(str);//不存在"("直接处理运行表达式
int cr = str.indexOf(')', cl);
String left = str.substring(0, cl);
String right = str.substring(cr + 1);
String middle = str.substring(cl + 1, cr);//如果存在"("提取括号中的表达式
return cacComplex(left + cac(middle) + right);
}

/**
* DESC:计算表达式,判断是否存在乘除运算,存在则先执行乘除运算,然后执行加减运算,返回运算结果;
* 不存在,直接运行加减运算,返回运算结果。
* @param str
* @return 运算结果
*/
private static String cac(String str) {
if (str.equals(""))
return "0";
int ml = str.indexOf('*');
int dl = str.indexOf('/');
if (ml == -1 && dl == -1) {
return cacNoMD(str);
}
int index = ml == -1 ? dl : ml;
String left = str.substring(0, index);
String m1 = lastNumber(left);
left = left.substring(0, left.length() - m1.length());
String right = str.substring(index + 1);
String m2 = firstNumber(right);
right = right.substring(m2.length());
String tmp = "0";
if (index == ml) {
tmp = ps.mul(m1, m2);
} else if (index == dl) {
tmp = ps.div(m1, m2, 4);
}
return cac(left + tmp + right);
}
    /**
     * Description:获得表达式的最后一位数字
     * @param str
     * @return 表达式最后一位数字
     */
private static String lastNumber(String str) {
StringBuilder sb = new StringBuilder();
for (int i = str.length() - 1; i >= 0; i--) {
char c = str.charAt(i);
if (!Character.isDigit(c) && c != '.')
break;
sb.append(c);
}
return sb.reverse().toString();
}

/**
* DESC:获得表达式的的一位数字
* @param str
* @return 表达式的第一位数字
*/
private static String firstNumber(String str) {
StringBuilder sb = new StringBuilder();
for (char c : str.toCharArray()) {
if (!Character.isDigit(c) && c != '.')
break;
sb.append(c);
}
return sb.toString();
}

/**
* DESC:加减运算表达式计算
* @param str
* @return 计算结果
*/
private static String cacNoMD(String str) {
String ret = "0";
StringBuilder sb = new StringBuilder();
char sign = '+';
for (char c : (str + "+").toCharArray()) {
if (!Character.isDigit(c) && c != '.') {
if (sb.length() == 0)
continue;
if (sign == '+') {
ret = ps.add(ret, sb.toString());
} else {
ret = ps.sub(ret, sb.toString());
}
sb = new StringBuilder();
sign = c;
} else {
sb.append(c);
}
}
return ret;
}

}
 
 
jdk1.6 
用 javax.script.ScriptEngine 的Object eval(String script)方法可以计算字符串表达式的值
具体可查考API和以下demo
----------------------------------------------------------------
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class T{
ScriptEngine jse;
public T(String s){
jse = new ScriptEngineManager().getEngineByName("JavaScript");
try{
Boolean res = (Boolean)jse.eval(s);
System.out.println(res);
}catch(Exception t){}
}
}
 
 

相关文章推荐

java执行字符串中的运算公式

public class runString { static ScriptEngine jse = new ScriptEngineManager().getEngineByName("Java...

java常用计算公式

主要为double类型计算 package com.xf.utils;import java.math.BigDecimal;public abstract class AmountUtil { ...

谈谈JAVA如何计算字符串公式

因为最近忙着面试,也没太多时间分享自己的博客,但因为面试的过程中,碰到了几道类似的算法题,都是输入一个字符串数学公式,输出结果。自己整理了下,希望能和大家交流交流。我是利用谭浩强那本C语言上的算法写的...

可以解析公式的java类实例--可传入数值运算表达式、含变量的运算表达式

前几天遇到一个问题,需要从xml文件里读取一个含参数的公式并调用它。    于是上网找方法,但是实在是没有找到可以解析含参数的公式的方法,于是吸取了一些精华,并在此基础上加以改造,终于实现了,但是这...

java将字符串转成算术表达式

转自http://bbs.csdn.net/topics/360244167 import javax.script.ScriptEngine; import javax.script.Sc...

java执行字符串中的运算公式

JDK自带的类可以实现调用JS的功能,可以实现执行字符串中的运算公式的功能。 [java] view plaincopyprint? public class runString ...

Google Instant Apps VS 微信小程序

前几天,Google 宣布面向所有开发者开放了 Android Instant Apps,所有开发者都可以制作和发布 Instant Apps 了。很多人其实还不太明白 Instant Apps 是啥...

java执行字符串公式

ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");         String strs = "...

java执行字符串中的运算公式

原文地址:http://blog.csdn.net/andymu077/article/details/25193589 通过JDK自带的JS引擎来实现,算是迂回吧,提供了一种新思路。 publi...

java把字符串转化成公式计算

static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript"); Object aa = jse....
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)