java 字符串公式计算 --------转载

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

/**

* 实现对字符串表达式进行简单的包括函数的运算。

* @author 时锐

*/

public class AnalyzeCalculate {

/**

* 定义运算符

*/

public static List<String> lc = new ArrayList<String>();

static {

lc.add("+");

lc.add("`");

lc.add("*");

lc.add("/");

}

/**

* 定义逻辑运算符

*/

public static List<String> lj = new ArrayList<String>();

static {

lj.add(">");

lj.add("<");

lj.add("=");

lj.add("!");

}

/**

* int数组注释,第一个标识:0自带函数 1自定义函数;第二个标识:参数个数

*/

public static Map<String, int[]> funMap = new HashMap<String, int[]>();

static {

// 自带函数,可利用反射机制

funMap.put("abs", new int[] { 0, 1 });

funMap.put("acos", new int[] { 0, 1 });

funMap.put("asin", new int[] { 0, 1 });

funMap.put("atan", new int[] { 0, 1 });

funMap.put("cbrt", new int[] { 0, 1 });

funMap.put("ceil", new int[] { 0, 1 });

funMap.put("cos", new int[] { 0, 1 });

funMap.put("cosh", new int[] { 0, 1 });

funMap.put("exp", new int[] { 0, 1 });

funMap.put("expm1", new int[] { 0, 1 });

funMap.put("floor", new int[] { 0, 1 });

funMap.put("log", new int[] { 0, 1 });

funMap.put("log10", new int[] { 0, 1 });

funMap.put("log1p", new int[] { 0, 1 });

funMap.put("random", new int[] { 0, 1 });

funMap.put("rint", new int[] { 0, 1 });

funMap.put("round", new int[] { 0, 1 });

funMap.put("signum", new int[] { 0, 1 });

funMap.put("sin", new int[] { 0, 1 });

funMap.put("sinh", new int[] { 0, 1 });

funMap.put("sqrt", new int[] { 0, 1 });

funMap.put("tan", new int[] { 0, 1 });

funMap.put("tanh", new int[] { 0, 1 });

funMap.put("max", new int[] { 0, 2 });

funMap.put("min", new int[] { 0, 2 });

// 自定义函数

funMap.put("if", new int[] { 1, 3 });

funMap.put("mod", new int[] { 1, 2 });

funMap.put("int", new int[] { 1, 1 });

}

/**

* 公式初始化转换

*

* @param str

* @return 处理过的计算客串

*/

public static String strCast(String str) {

str = str.toLowerCase();// 去除空格，变小写

if (str == null ? true : str.length() == 0)

return "0";

if (!checkFormula(str))

return "0";

str = str.replaceAll("\\*-", "**");

str = str.replaceAll("-\\*", "**");

str = str.replaceAll("/-", "//");

str = str.replaceAll("-/", "//");

str = str.replaceAll("\\+-", "-");

str = str.replaceAll("-\\+", "-");

str = str.replaceAll("-", "`");

str = str.replaceAll("\\*\\*", "*-");

str = str.replaceAll("//", "/-");

str = str.replaceAll(" ", "");

return str;

}

/**

* 检查公式中括号出现次数是否正确

*

* @param formulaStr

* @return 公式中的括号是否成对

*/

public static boolean checkFormula(String formulaStr) {

boolean flag = true;

int count = 0;

for (int i = 0; i < formulaStr.length(); i++) {

String s = String.valueOf(formulaStr.charAt(i));

if ("(".equals(s))

count++;

else if (")".equals(s))

count--;

}

flag = count == 0;

return flag;

}

/**

* 分割函数

*

* @param str

* @param bs

* @return 分割后的客串

*/

public static String[] spliteFun(String str, String bs) {

List<String> list = new ArrayList<String>();

String bds = "";

int bracket = 0;

int len = str.length();

for (int i = 0; i < len; i++) {

String s = String.valueOf(str.charAt(i));

if ("(".equals(s)) {

bracket++;

} else if (")".equals(s)) {

bracket--;

}

if (bracket == 0 && bs.equals(s)) {

list.add(bds);

bds = "";

continue;

}

bds += s;

}

list.add(bds);

String[] ss = new String[list.size()];

for (int i = 0; i < list.size(); i++) {

ss[i] = list.get(i);

}

return ss;

}

/**

* 用户自定义函数

*

* @param str

* @param funStr

* @return 处理用户自定义函数

*/

public static String customFun(String str, String funStr) {

String reval = "0";

String[] gss = spliteFun(str, ",");

if ("if".equals(funStr)) {

if (compare(gss[0])) {

reval = calculate(gss[1]);

} else {

reval = calculate(gss[2]);

}

} else if ("mod".equals(funStr)) {

double d2 = new Double(calculate(gss[1]));

if (d2 == 0)

return reval;

double d1 = new Double(calculate(gss[0]));

reval = (d1 % d2) + "";

} else if ("int".equals(funStr)) {

reval = Math.floor(new Double(calculate(gss[0]))) + "";

}

return reval;

}

/**

* 逻辑表达式判断

* @param str

* @return true or false

*/

public static boolean compare(String str) {

boolean flag = false;

boolean bs = false;

int len = str.length();

int bracket = 0;

String ljbds = "";

double d_left = 0;

double d_right = 0;

for (int i = 0; i < len; i++) {

String s = String.valueOf(str.charAt(i));

if ("(".equals(s)) {

bracket++;

} else if (")".equals(s)) {

bracket--;

}

if (bracket == 0 && lj.contains(s)) {

for (int j = i; j < len; j++) {

String ts = String.valueOf(str.charAt(j));

if (lj.contains(ts)) {

ljbds += ts;

} else {

bs = true;

break;

}

}

}

if (bs)

break;

}

String[] s = str.split(ljbds);

d_left = new Double(calculate(s[0]));

d_right = new Double(calculate(s[1]));

if ("<".equals(ljbds)) {

if (d_left < d_right)

return true;

} else if (">".equals(ljbds)) {

if (d_left > d_right)

return true;

} else if ("=".equals(ljbds)) {

if (d_left == d_right)

return true;

} else if (">=".equals(ljbds)) {

if (d_left >= d_right)

return true;

} else if ("<=".equals(ljbds)) {

if (d_left <= d_right)

return true;

} else if ("<>".equals(ljbds) || "!=".equals(ljbds)) {

if (d_left != d_right)

return true;

}

return flag;

}

/**

* 递归调用运算

*

* @param str

* @return String

*/

public static String calculate(String str) {

String reval = "";

String bds = "";

int bracket = 0;// 对应括号个数

int pos = 0;

boolean title = false;

if (str.substring(0, 1).equals("`")) {

str = str.substring(1);

title = true;

}

int len = str.length();

for (int i = 0; i < len; i++) {

String s = String.valueOf(str.charAt(i));

pos = i;

bracket = 0;

if (!lc.contains(s)) {// 如果没遇到运算符

if ("(".equals(s)) {// 如果遇到左括号

if (funMap.containsKey(bds)) {// 如果左括号前是函数

for (int j = i + 1; j < len; j++) {// 从左括号后开始循环

pos++;// 累计移动字符位数

String ts = String.valueOf(str.charAt(j));// 单个字符

// reval+=ts;

if ("(".equals(ts))// 如果是左括号累计

bracket++;

else if (")".equals(ts)) {// 如果是右括号进行减少

bracket--;

if (bracket == -1) {// 如果是-1,标识括号结束

reval = reval.substring(0, reval.length()

- bds.length());// 重新获得去掉函数头的表达式

reval += funCalculate(str.substring(i + 1,

j), bds);// 表达式加上函数结果,形成新表达式

i = pos;// 计数器增加

bds = "";// 函数头清空

break;// 退出本次循环

}

}

}

} else {// 如果是普通运算

for (int j = i + 1; j < len; j++) {

pos++;

String ts = String.valueOf(str.charAt(j));

if ("(".equals(ts))

bracket++;

else if (")".equals(ts)) {

bracket--;

if (bracket == -1) {

reval += calculate(str

.substring(i + 1, pos));

i = pos;

bds = "";

break;

}

}

}

}

} else {// 累加总表达式和最后一个运算数(或函数)

bds += s;

reval += s;

}

} else {// 遇到运算符最后一个运算数(或函数)清空

bds = "";

reval += s;

}

}

if (title)

reval = "-" + reval;

return szys(reval);

}

/**

* 函数运算

*

* @param gs

* @param flag

* @return String

*/

public static String funCalculate(String gs, String funStr) {

String rval = "0";

if (funMap.containsKey(funStr)) {

int[] csi = funMap.get(funStr);

try {

if (csi[0] == 0) {// java内部函数,通过反射调用

Class[] cs = new Class[csi[1]];

Object[] objs = new Object[csi[1]];

String[] gss = zlcs(gs);

for (int i = 0; i < csi[1]; i++) {

cs[i] = double.class;

objs[i] = new Double(calculate(gss[i]));

}

Class cls = Class.forName("java.lang.Math");

Method m = cls.getMethod("abs", cs);

rval = String.valueOf(m.invoke(cls, objs));

} else if (csi[0] == 1) {// 自定义函数

rval = customFun(gs, funStr);

}

} catch (Exception e) {

}

}

return rval;

}

/**

* 公式里的参数分割

* @param str

* @return String[]

*/

public static String[] zlcs(String str) {

int len = str.length();

boolean flag = true;

String tstr = "";

for (int i = 0; i < len; i++) {

String s = String.valueOf(str.charAt(i));

if ("(".equals(s)) {

flag = false;

} else if (")".equals(s)) {

flag = true;

}

if (flag && ",".equals(s)) {

tstr += "@";

} else {

tstr += s;

}

}

return tstr.split("@");

}

/**

* 四则运算表达式处理

*

* @param str

* @return String

*/

public static String szys(String gs) {

gs = gs + "+0"; // 因为下面的计算是遇到符号才进行,所以多加入一个计算符号,不影响值.

String c1 = "";// 第一个运算符号

String c2 = "";// 第二个运算符号

String s1 = "";// 第一个运算数

String s2 = "";// 第二个运算数

String s3 = "";// 第三个运算数

int len = gs.length();

for (int i = 0; i < len; i++) {

String s = String.valueOf(gs.charAt(i));// 获得该位置字符并转换成字符串做比较

if (lc.contains(s)) { // 如果是运算符号

if (c1.length() == 0)// 如果第一个运算符号为空,加入

c1 = s;

else if (c2.length() == 0) {// 否则,如果第二个运算符号为空,加入

c2 = s;// 第二个运算符号

if ("+".equals(c2) || "`".equals(c2)) {// 如果第二个运算符号级别低,那么进行计算

s1 = _4zys(s1, c1, s2);// 第一个和第二个数计算

c1 = c2;// 保存第二个运算符,其他为空

c2 = "";

s2 = "";

}

} else {// 上述都保存过

if ("+".equals(s) || "`".equals(s)) {// 如果第三个运算符级别低,进行运算

s2 = _4zys(s2, c2, s3);// 先算第二三个数,保存至第二个

s1 = _4zys(s1, c1, s2);// 再算第一二个,保存至第一个

c1 = s;// 保存当前运算符,其他为空

s2 = "";

c2 = "";

s3 = "";

} else {// 如果第三个运算符级别高

s2 = _4zys(s2, c2, s3);// 先算第二三个数,保存至第二个

c2 = s;// 前面不动,保存运算符

s3 = "";

}

}

} else if (s1.length() > 0 && c1.length() > 0 && c2.length() == 0) {// 如果第一个数,第一个运算符已保存,第二个运算符未保存,保存第二哥数

s2 += s;

} else if (c1.length() == 0) {// 如果没有运算符,保存第一个数

s1 += s;

} else if (s1.length() > 0 && s2.length() > 0 && c1.length() > 0

&& c2.length() > 0) {// 如果第一二个数和运算符都有,保存第三个数

s3 += s;

}

}

return s1;

}

/**

* 基本四则运算

*

* @param c1

* 运算数1

* @param s1

* 运算符(加减乘除)

* @param c2

* 运算数2

* @return String

*/

public static String _4zys(String c1, String s1, String c2) {

String reval = "0";

try {

double ln = Double.valueOf(c1).doubleValue();

double rn = Double.valueOf(c2).doubleValue();

if ("+".equals(s1)) {

return (ln + rn) + "";

} else if ("`".equals(s1)) {

return (ln - rn) + "";

} else if ("*".equals(s1)) {

return (ln * rn) + "";

} else if ("/".equals(s1)) {

if (rn == 0)

return reval;

else

return (ln / rn) + "";

}

} catch (Exception e) {

} finally {

}

return reval;

}

/**

* 测试

* @param args

*/

public static void main(String[] args) {

String gs = "if(4 > 3,if( ( 2 - 1 ) / ( 0.0001 ) * 3 > 3 , ( 2 - ( 2 - 1 ) / ( 0.0001 ) * 3 ) * 0.8 ,0), ( 2 + ( 3 - 2 ) / ( 0.0001 ) *1 ) * 1)";

// 进行四则运算获得结果

System.out.println(szys(strCast("3-4*-5+5")));

System.out.println(calculate(strCast("3-4*-5+5")));

// 函数运算结果

System.out

.println(calculate(strCast("3+abs(mod(4,if(2>3,1,3))-abs(2*4))*5+5")));

System.out.println(calculate(strCast("if(0.0*2>=10.0,0,10.0-0.0*2)")));

System.out.println(calculate(strCast("if(0<2,(10.0-0*5)*0.8,0)")));

System.out.println(calculate(strCast("-10/0")));

}

}