转化字符串表达式为数学公式并算出结果

/*



* FormulaCalculator.java



*



* Created on 2007年9月18日, 上午11:40



* @title 转化字符串表达式为数学公式并算出结果



* @description 转化字符串表达式为数学公式并算出结果



* 注意:为了区分负号，这边使用#代替减号



* 使用方法:



* FormulaCalculator calculator=new FormulaCalculator();



* calculator.getResult("10.23#20.67*(5.12+7.82)/2",2);



* v1.0.0 created by chenfc



*



*/





package
org.jceun;





import
java.math.BigDecimal;



import
java.util.LinkedList;



import
java.util.ArrayList;



import
java.util.regex.Matcher;



import
java.util.regex.Pattern;







public

class
FormulaCalculator
...
{



private

boolean
isRightFormat
=

true
;



public
String DIVISOR_EQUALS_ZERO
=
"
0.0
"
;
//
除数为零时的返回值





/** */
/**



* 为了区分负号，这边使用#代替减号



*
@param
formula 字符串表达式



*
@return
返回公式计算结果



*/





public

double
getResult(String formula)
...
{



double
returnValue
=

0
;





try
...
{



returnValue
=
doAnalysis(formula);





}

catch
(NumberFormatException nfe)
...
{



System.out.println(
"
公式格式有误，请检查:
"

+
formula);





}

catch
(Exception e)
...
{



e.printStackTrace();



}





if
(
!
isRightFormat)
...
{



System.out.println(
"
公式格式有误，请检查:
"

+
formula);



}



return
returnValue;



}





/** */
/**



* 采用BigDecimal.ROUND_HALF_UP方式返回指定精度的运算结果



*
@param
formula 公式



*
@param
decimalPlace 要保留的小数位数



*
@return
返回公式计算结果



*/





public
String getResult(String formula,
int
decimalPlace)
...
{



return
getResult(formula,decimalPlace,BigDecimal.ROUND_HALF_UP);



}





/** */
/**



* 返回指定精度及舍去尾数的策略的运算结果



*
@param
formula 公式



*
@param
decimalPlace 要保留的小数位数



*
@param
roundMethod 舍去尾数的策略



* 可取值有BigDecimal.ROUND_HALF_UP BigDecimal.ROUND_HALF_DOWN祥见BigDecimal



*
@return
返回公式计算结果



*/





public
String getResult(String formula,
int
decimalPlace,
int
roundMethod)
...
{



double
result
=
getResult(formula);



if
(result
==
Double.MAX_VALUE)



return
DIVISOR_EQUALS_ZERO;



else



return
numberAround(result,decimalPlace,roundMethod);



}





private

double
doAnalysis(String formula)
...
{



double
returnValue
=

0
;



LinkedList
<
Integer
>
stack
=

new
LinkedList
<
Integer
>
();





int
curPos
=

0
;



String beforePart
=

""
;



String afterPart
=

""
;



String calculator
=

""
;



isRightFormat
=

true
;





while
(isRightFormat
&&
(formula.indexOf(
'
(
'
)
>=

0
||
formula.indexOf(
'
)
'
)
>=

0
))
...
{



curPos
=

0
;





for
(
char
s : formula.toCharArray())
...
{





if
(s
==

'
(
'
)
...
{



stack.add(curPos);





}

else

if
(s
==

'
)
'
)
...
{





if
(stack.size()
>

0
)
...
{



beforePart
=
formula.substring(
0
, stack.getLast());



afterPart
=
formula.substring(curPos
+

1
);



calculator
=
formula.substring(stack.getLast()
+

1
, curPos);



formula
=
beforePart
+
doCalculation(calculator)
+
afterPart;



stack.clear();



break
;





}

else
...
{



System.out.println(
"
有未关闭的右括号！
"
);



isRightFormat
=

false
;



}



}



curPos
++
;



}





if
(stack.size()
>

0
)
...
{



System.out.println(
"
有未关闭的左括号！
"
);



break
;



}



}





if
(isRightFormat)
...
{



returnValue
=
doCalculation(formula);



}



return
returnValue;



}





/** */
/**



* 为了区分负号，这边使用#代替减号



*/





private

double
doCalculation(String formula)
...
{



ArrayList
<
Double
>
values
=

new
ArrayList
<
Double
>
();



ArrayList
<
String
>
operators
=

new
ArrayList
<
String
>
();



int
curPos
=

0
;



int
prePos
=

0
;





for
(
char
s : formula.toCharArray())
...
{





if
(s
==

'
+
'

||
s
==

'
#
'

||
s
==

'
*
'

||
s
==

'
/
'
)
...
{



values.add(Double.parseDouble(formula.substring(prePos, curPos)



.trim()));



operators.add(
""

+
s);



prePos
=
curPos
+

1
;



}



curPos
++
;



}



values.add(Double.parseDouble(formula.substring(prePos).trim()));



char
op;





for
(curPos
=
operators.size()
-

1
; curPos
>=

0
; curPos
--
)
...
{



op
=
operators.get(curPos).charAt(
0
);





switch
(op)
...
{



case

'
*
'
:



values.add(curPos, values.get(curPos)
*
values.get(curPos
+

1
));



values.remove(curPos
+

1
);



values.remove(curPos
+

1
);



operators.remove(curPos);



break
;



case

'
/
'
:



if
(values.get(curPos
+

1
).doubleValue()
==
0.0
)
//
除数为零时



values.add(curPos,
new
Double(getDefaultValue()));



else



values.add(curPos, values.get(curPos)
/
values.get(curPos
+

1
));



values.remove(curPos
+

1
);



values.remove(curPos
+

1
);



operators.remove(curPos);



break
;



}



}





for
(curPos
=
operators.size()
-

1
; curPos
>=

0
; curPos
--
)
...
{



op
=
operators.get(curPos).charAt(
0
);





switch
(op)
...
{



case

'
+
'
:



values.add(curPos, values.get(curPos)
+
values.get(curPos
+

1
));



values.remove(curPos
+

1
);



values.remove(curPos
+

1
);



operators.remove(curPos);



break
;



case

'
#
'
:



values.add(curPos, values.get(curPos)
-
values.get(curPos
+

1
));



values.remove(curPos
+

1
);



values.remove(curPos
+

1
);



operators.remove(curPos);



break
;



}



}



return
values.get(
0
).doubleValue();



}





/** */
/**



* 对数字进行四舍五入



*
@param
dN 要四舍五入的数



*
@param
decimalPlace 精度



*
@param
roundMethod 舍去尾数的策略



* 可取值有BigDecimal.ROUND_HALF_UP BigDecimal.ROUND_HALF_DOWN祥见BigDecimal



*/





public
String numberAround(
double
dN,
int
decimalPlace,
int
roundMethod)
...
{



BigDecimal bd
=

new
BigDecimal(String.valueOf(dN));



bd
=
bd.setScale(decimalPlace, roundMethod);



return
String.valueOf(bd);



}





/** */
/**



* 对给定的字符串进行模式匹配



*
@param
str 要匹配的字符串



*
@param
regix 模式



*
@return
返回匹配结果，成功为true,否则为false



*
*/





public

boolean
check(String str,String regix)
...
{



boolean
result
=
false
;



Pattern p
=
Pattern.compile(regix);



Matcher m
=
p.matcher(str);



result
=
m.matches();



return
result;



}



}