Java计算数学表达式代码详解

 更新时间:2017年12月07日 08:43:02   作者:woider  
这篇文章主要介绍了Java计算数学表达式代码详解,具有一定借鉴价值,需要的朋友可以了解下。

Java字符串转换成算术表达式计算并输出结果,通过这个工具可以直接对字符串形式的算术表达式进行运算,并且使用非常简单。

这个工具中包含两个类 Calculator 和 ArithHelper

Calculator 代码如下:

import java.util.Collections;
import java.util.Stack;
/**
 * 算数表达式求值 
 * 直接调用Calculator的类方法conversion() 
 * 传入算数表达式,将返回一个浮点值结果
 * 如果计算过程错误,将返回一个NaN
 */
public class Calculator {
	private Stack<String> postfixStack = new Stack<String>();
	// 后缀式栈
	private Stack<Character> opStack = new Stack<Character>();
	// 运算符栈
	private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };
	// 运用运算符ASCII码-40做索引的运算符优先级
	public static double conversion(String expression) {
		double result = 0;
		Calculator cal = new Calculator();
		try {
			expression = transform(expression);
			result = cal.calculate(expression);
		}
		catch (Exception e) {
			// e.printStackTrace();
			// 运算错误返回NaN
			return 0.0 / 0.0;
		}
		// return new String().valueOf(result);
		return result;
	}
	/**
   * 将表达式中负数的符号更改
   *
   * @param expression
   *      例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
   * @return
   */
	private static String transform(String expression) {
		char[] arr = expression.toCharArray();
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == '-') {
				if (i == 0) {
					arr[i] = '~';
				} else {
					char c = arr[i - 1];
					if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
						arr[i] = '~';
					}
				}
			}
		}
		if(arr[0]=='~'||arr[1]=='('){
			arr[0]='-';
			return "0"+new String(arr);
		} else{
			return new String(arr);
		}
	}
	/**
   * 按照给定的表达式计算
   *
   * @param expression
   *      要计算的表达式例如:5+12*(3+5)/7
   * @return
   */
	public double calculate(String expression) {
		Stack<String> resultStack = new Stack<String>();
		prepare(expression);
		Collections.reverse(postfixStack);
		// 将后缀式栈反转
		String firstValue, secondValue, currentValue;
		// 参与计算的第一个值,第二个值和算术运算符
		while (!postfixStack.isEmpty()) {
			currentValue = postfixStack.pop();
			if (!isOperator(currentValue.charAt(0))) {
				// 如果不是运算符则存入操作数栈中
				currentValue = currentValue.replace("~", "-");
				resultStack.push(currentValue);
			} else {
				// 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
				secondValue = resultStack.pop();
				firstValue = resultStack.pop();
				// 将负数标记符改为负号
				firstValue = firstValue.replace("~", "-");
				secondValue = secondValue.replace("~", "-");
				String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
				resultStack.push(tempResult);
			}
		}
		return double.valueOf(resultStack.pop());
	}
	/**
   * 数据准备阶段将表达式转换成为后缀式栈
   * 
   * @param expression
   */
	private void prepare(String expression) {
		opStack.push(',');
		// 运算符放入栈底元素逗号,此符号优先级最低
		char[] arr = expression.toCharArray();
		int currentIndex = 0;
		// 当前字符的位置
		int count = 0;
		// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
		char currentOp, peekOp;
		// 当前操作符和栈顶操作符
		for (int i = 0; i < arr.length; i++) {
			currentOp = arr[i];
			if (isOperator(currentOp)) {
				// 如果当前字符是运算符
				if (count > 0) {
					postfixStack.push(new String(arr, currentIndex, count));
					// 取两个运算符之间的数字
				}
				peekOp = opStack.peek();
				if (currentOp == ')') {
					// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
					while (opStack.peek() != '(') {
						postfixStack.push(String.valueOf(opStack.pop()));
					}
					opStack.pop();
				} else {
					while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
						postfixStack.push(String.valueOf(opStack.pop()));
						peekOp = opStack.peek();
					}
					opStack.push(currentOp);
				}
				count = 0;
				currentIndex = i + 1;
			} else {
				count++;
			}
		}
		if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {
			// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
			postfixStack.push(new String(arr, currentIndex, count));
		}
		while (opStack.peek() != ',') {
			postfixStack.push(String.valueOf(opStack.pop()));
			// 将操作符栈中的剩余的元素添加到后缀式栈中
		}
	}
	/**
   * 判断是否为算术符号
   *
   * @param c
   * @return
   */
	private Boolean isOperator(char c) {
		return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
	}
	/**
   * 利用ASCII码-40做下标去算术符号优先级
   *
   * @param cur
   * @param peek
   * @return
   */
	public Boolean compare(char cur, char peek) {
		// 如果是peek优先级高于cur,返回true,默认都是peek优先级要低
		Boolean result = false;
		if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
			result = true;
		}
		return result;
	}
	/**
   * 按照给定的算术运算符做计算
   *
   * @param firstValue
   * @param secondValue
   * @param currentOp
   * @return
   */
	private String calculate(String firstValue, String secondValue, char currentOp) {
		String result = "";
		switch (currentOp) {
			case '+':
			      result = String.valueOf(ArithHelper.add(firstValue, secondValue));
			break;
			case '-':
			      result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
			break;
			case '*':
			      result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
			break;
			case '/':
			      result = String.valueOf(ArithHelper.div(firstValue, secondValue));
			break;
		}
		return result;
	}
}

ArithHelper 代码如下:

public class ArithHelper {
	// 默认除法运算精度
	private static final int DEF_DIV_SCALE = 16;
	// 这个类不能实例化
	private ArithHelper() {
	}
	/**
   * 提供精确的加法运算。
   *
   * @param v1 被加数
   * @param v2 加数
   * @return 两个参数的和
   */
	public static double add(double v1, double v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
		return b1.add(b2).doubleValue();
	}
	public static double add(String v1, String v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
		return b1.add(b2).doubleValue();
	}
	/**
   * 提供精确的减法运算。
   *
   * @param v1 被减数
   * @param v2 减数
   * @return 两个参数的差
   */
	public static double sub(double v1, double v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
		return b1.subtract(b2).doubleValue();
	}
	public static double sub(String v1, String v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
		return b1.subtract(b2).doubleValue();
	}
	/**
   * 提供精确的乘法运算。
   *
   * @param v1
   *      被乘数
   * @param v2
   *      乘数
   * @return 两个参数的积
   */
	public static double mul(double v1, double v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
		return b1.multiply(b2).doubleValue();
	}
	public static double mul(String v1, String v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
		java.math.BigDecimal b2 = new java.math.BigDecimal(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);
	}
	public static double div(String v1, String v2) {
		java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
		java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
		return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	/**
   * 提供(相对)精确的除法运算。当发生除不尽的情况时,由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");
		}
		java.math.BigDecimal b1 = new java.math.BigDecimal(double.toString(v1));
		java.math.BigDecimal b2 = new java.math.BigDecimal(double.toString(v2));
		return b1.divide(b2, scale, java.math.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");
		}
		java.math.BigDecimal b = new java.math.BigDecimal(double.toString(v));
		java.math.BigDecimal one = new java.math.BigDecimal("1");
		return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	public static double round(String v, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
		}
		java.math.BigDecimal b = new java.math.BigDecimal(v);
		java.math.BigDecimal one = new java.math.BigDecimal("1");
		return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
	}
}

使用时调用 Calculator 类的 conversion()方法,并传入算术表达式参数,即可返回一个 Double 类型的值。

使用示例:

public class MathTest {
	public static void main(String[] args) {
		String expression = "(0*1--3)-5/-4-(3*(-2.13))";
		double result = Calculator.conversion(expression);
		System.out.println(expression + " = " + result);
		System.out.println();
	}
}

控制台输出:

(0*1--3)-5/-4-(3*(-2.13)) = 10.64

测试截图:

总结

以上就是本文关于Java计算数学表达式代码详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

相关文章

  • 一文了解mybatis的延迟加载

    一文了解mybatis的延迟加载

    本文主要为大家详细介绍下mybatis的延迟加载,从原理上介绍下怎么使用、有什么好处能规避什么问题。感兴趣的小伙伴可以跟随小编一起学习一下
    2022-07-07
  • 分析并发编程之LongAdder原理

    分析并发编程之LongAdder原理

    LongAdder类是JDK1.8新增的一个原子性操作类。AtomicLong通过CAS算法提供了非阻塞的原子性操作,相比受用阻塞算法的同步器来说性能已经很好了,但是JDK开发组并不满足于此,因为非常搞并发的请求下AtomicLong的性能是不能让人接受的
    2021-06-06
  • Java String类的性质与比较

    Java String类的性质与比较

    字符串广泛应用 在 Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串,本文将为你带来详细介绍,感兴趣的朋友继续往下看吧
    2021-10-10
  • SpringBoot/Spring AOP默认动态代理方式实例详解

    SpringBoot/Spring AOP默认动态代理方式实例详解

    这篇文章主要给大家介绍了关于SpringBoot/Spring AOP默认动态代理方式的相关资料,Spring AOP是一款基于Java的AOP框架,其中默认采用动态代理方式实现AOP功能,本文将详细介绍动态代理的实现原理和使用方法,需要的朋友可以参考下
    2023-03-03
  • springboot 中文件上传下载实例代码

    springboot 中文件上传下载实例代码

    Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。这篇文章主要介绍了springboot 中文件上传下载实例代码,需要的朋友可以参考下
    2017-11-11
  • @TableName注解和@Table的区别及说明

    @TableName注解和@Table的区别及说明

    这篇文章主要介绍了@TableName注解和@Table的区别及说明,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-01-01
  • Spring Junit测试找不到SpringJUnit4ClassRunner.class的解决

    Spring Junit测试找不到SpringJUnit4ClassRunner.class的解决

    这篇文章主要介绍了Spring Junit测试找不到SpringJUnit4ClassRunner.class的解决方案,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-04-04
  • 微信公众号开发之设置自定义菜单实例代码【java版】

    微信公众号开发之设置自定义菜单实例代码【java版】

    这篇文章主要介绍了微信公众号开发之设置自定义菜单实例代码,本实例是为了实现在管理后台实现微信菜单的添加删除管理。需要的朋友可以参考下
    2018-06-06
  • Java排序算法之堆排思想及代码实现

    Java排序算法之堆排思想及代码实现

    今天小编就为大家分享一篇关于Java排序算法之堆排思想及代码实现,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2019-01-01
  • Java类加载器ClassLoader的使用详解

    Java类加载器ClassLoader的使用详解

    类加载器负责读取Java字节代码,并转换成java.lang.Class类的一个实例的代码模块。本文主要和大家聊聊JVM类加载器ClassLoader的使用,需要的可以了解一下
    2022-12-12

最新评论