Java解析四则算式工具类

[selling-dreams]

import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* 描述：解析四则算式并计算
* @author
* @date 2019年06月18日 16:48:26
* @since
*/
public class Math {
// 全局正则定义
/**
* 乘除正则，查找乘除操作
*/
private static String mul_div_calc_regex = "\\d+(\\.\\d+)?[\\*\\/]\\d+(\\.\\d+)?";
/**
* 加减正则，查找加减操作
*/
private static String plus_sub_calc_regex = "\\d+(\\.\\d+)?[\\+\\-]\\d+(\\.\\d+)?";
/**
* 括号正则，查找括号运算
*/
private static String mark_regex = "\\([^\\(]*?\\)";
/**
* 运算正则，查找具体操作
*/
private static String calc_regex = "[\\+\\-\\*\\/]";

/**
* 功能描述：简单计算
* @author
* @date 2019年06月18日 17:50:25
* @param a
* @param mark
* @param b
* @return java.lang.String
*/
public static String basic_calc(String a, String mark, String b){
double v1 = Double.parseDouble(a);
double v2 = Double.parseDouble(b);
String ans = "";
if("*".equals(mark)){
ans = String.valueOf(Arith.mul(v1, v2));
}else if("/".equals(mark)){
ans = String.valueOf(Arith.div(v1, v2));
}else if("+".equals(mark)){
ans = String.valueOf(Arith.add(v1, v2));
}else if("-".equals(mark)){
ans = String.valueOf(Arith.sub(v1, v2));
}
return ans;
}

/**
* 功能描述：字符串拆分计算
* @author
* @date 2019年06月18日 17:50:40
* @param s
* @return java.lang.String
*/
public static String calc_by_string(String s){
// 判断是否以"-"开头
boolean isNegative = false;
if(s.startsWith("-")){
s = s.substring(1);
isNegative = true;
}
String[] arr = s.split(calc_regex);
Pattern pattern = Pattern.compile(calc_regex);
Matcher matcher = pattern.matcher(s);
String mark = "";
while (matcher.find()){
mark = matcher.group();
}
if(isNegative){
arr[0] = "-"+arr[0];
}
return basic_calc(arr[0], mark, arr[1]);
}

/**
* 功能描述：查找字符串中乘除操作，并计算
* @author
* @date 2019年06月18日 17:50:54
* @param s
* @return java.lang.String
*/
public static String mul_div(String s){
String ans = "";
String a = "";
Pattern pattern = Pattern.compile(mul_div_calc_regex);
Matcher matcher = null;
while (pattern.matcher(s).find()) {
matcher = pattern.matcher(s);
while (matcher.find()) {
a = matcher.group();
ans = calc_by_string(a);
s = s.replace(a, ans);
}
}
return s;
}

/**
* 功能描述：查找字符串中加减操作，并计算
* @author
* @date 2019年06月18日 17:51:04
* @param s
* @return java.lang.String
*/
public static String plus_sub(String s){
// 判断是否以"-"开头
boolean isNegative = false;
String ans = "";
String a = "";
Pattern pattern = Pattern.compile(plus_sub_calc_regex);
Matcher matcher = null;
while (pattern.matcher(s).find()) {
matcher = pattern.matcher(s);
while (matcher.find()) {
if(s.startsWith("-")){
isNegative = true;
}
a = matcher.group();
if(isNegative){
a = "-"+a;
}
ans = calc_by_string(a);
s = s.replace(a, ans);
isNegative = false;
}
}
return s;
}

/**
* 功能描述：计算一个简单等式，不包含括号
* @author
* @date 2019年06月18日 17:51:14
* @param s
* @return java.lang.String
*/
public static String calc_one(String s){
return plus_sub(mul_div(s));
}

/**
* 功能描述：查找括号，并计算
* @author
* @date 2019年06月18日 17:51:25
* @param s
* @return java.lang.String
*/
public static String mark_calc(String s){
String ans = "";
String a = "";
Pattern pattern = Pattern.compile(mark_regex);
Matcher matcher = null;
while (pattern.matcher(s).find()) {
matcher = pattern.matcher(s);
while (matcher.find()) {
a = matcher.group();
ans = calc_one(a.substring(1, a.length()-1));
// *和/之间是否夹杂-，并对其做处理
if(ans.indexOf("*")!=-1||ans.indexOf("/")!=-1){
if(ans.split("-").length%2==0){
ans = ans.replace("-", "");
ans = "-"+ans;
}else{
ans = ans.replace("-", "");
}
}
s = s.replace(a, ans);
}
}
// 对--和+-做处理
s = s.replace("+-", "-");
s = s.replace("--", "+");
return s;
}

/**
* 功能描述：全部计算
* @author
* @date 2019年06月18日 17:51:35
* @param s
* @return java.lang.String
*/
public static String calc_all(String s){
DecimalFormat df = new DecimalFormat("0.00");
// 去除s中的空格
s = s.replace(" ","");
String value = plus_sub(mul_div(mark_calc(s)));
return df.format(Double.parseDouble(value));
}
/***********************************************************/
/***********************************************************/
import java.math.BigDecimal;

/**
* 描述：精确的浮点数运算
*
* @author
* @date
* @since
*/
public class Arith
{

/** 默认除法运算精度 */
private static final int DEF_DIV_SCALE = 10;

/** 这个类不能实例化 */
private Arith()
{
}

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

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

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

/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2)
{
return div(v1, v2, DEF_DIV_SCALE);
}

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

/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale)
{
if (scale < 0)
{
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
}

[selling-dreams]

已经测试过。