Java实现简易计算器

淡淡的烟草味﹌ 2022-04-06 03:40 401阅读 0赞

一，Calculator — 表达式解析及计算

  1. package com.test;
  3. /**
  4.  * @author yangpan
  5.  * @Title: sell
  6.  * @Package com.citymine.kafka.kafka
  7.  * @Description:
  8.  * @date 2018/8/2215:52
  9.  */
  10. import java.util.Collections;
  11. import java.util.Stack;
  13. /**
  14.  *  算数表达式求值
  15.  *  直接调用Calculator的类方法conversion()
  16.  *  传入算数表达式，将返回一个浮点值结果
  17.  *  如果计算过程错误，将返回一个NaN
  18.  */
  19. public class Calculator {
  20.     private Stack<String> postfixStack = new Stack<String>();// 后缀式栈
  21.     private Stack<Character> opStack = new Stack<Character>();// 运算符栈
  22.     private int[] operatPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };// 运用运算符ASCII码-40做索引的运算符优先级
  24.     public static double conversion(String expression) {
  25.         double result = 0;
  26.         Calculator cal = new Calculator();
  27.         try {
  28.             expression = transform(expression);
  29.             result = cal.calculate(expression);
  30.         } catch (Exception e) {
  31.             // e.printStackTrace();
  32.             // 运算错误返回NaN
  33.             return 0.0 / 0.0;
  34.         }
  35.         // return new String().valueOf(result);
  36.         return result;
  37.     }
  39.     /**
  40.      * 将表达式中负数的符号更改
  41.      *
  42.      * @param expression
  43.      *            例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
  44.      * @return
  45.      */
  46.     private static String transform(String expression) {
  47.         char[] arr = expression.toCharArray();
  48.         for (int i = 0; i < arr.length; i++) {
  49.             if (arr[i] == '-') {
  50.                 if (i == 0) {
  51.                     arr[i] = '~';
  52.                 } else {
  53.                     char c = arr[i - 1];
  54.                     if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
  55.                         arr[i] = '~';
  56.                     }
  57.                 }
  58.             }
  59.         }
  60.         if(arr[0]=='~'||arr[1]=='('){
  61.             arr[0]='-';
  62.             return "0"+new String(arr);
  63.         }else{
  64.             return new String(arr);
  65.         }
  66.     }
  68.     /**
  69.      * 按照给定的表达式计算
  70.      *
  71.      * @param expression
  72.      *            要计算的表达式例如:5+12*(3+5)/7
  73.      * @return
  74.      */
  75.     public double calculate(String expression) {
  76.         Stack<String> resultStack = new Stack<String>();
  77.         prepare(expression);
  78.         Collections.reverse(postfixStack);// 将后缀式栈反转
  79.         String firstValue, secondValue, currentValue;// 参与计算的第一个值，第二个值和算术运算符
  80.         while (!postfixStack.isEmpty()) {
  81.             currentValue = postfixStack.pop();
  82.             if (!isOperator(currentValue.charAt(0))) {// 如果不是运算符则存入操作数栈中
  83.                 currentValue = currentValue.replace("~", "-");
  84.                 resultStack.push(currentValue);
  85.             } else {// 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
  86.                 secondValue = resultStack.pop();
  87.                 firstValue = resultStack.pop();
  89.                 // 将负数标记符改为负号
  90.                 firstValue = firstValue.replace("~", "-");
  91.                 secondValue = secondValue.replace("~", "-");
  93.                 String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
  94.                 resultStack.push(tempResult);
  95.             }
  96.         }
  97.         return Double.valueOf(resultStack.pop());
  98.     }
  100.     /**
  101.      * 数据准备阶段将表达式转换成为后缀式栈
  102.      *
  103.      * @param expression
  104.      */
  105.     private void prepare(String expression) {
  106.         opStack.push(',');// 运算符放入栈底元素逗号，此符号优先级最低
  107.         char[] arr = expression.toCharArray();
  108.         int currentIndex = 0;// 当前字符的位置
  109.         int count = 0;// 上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
  110.         char currentOp, peekOp;// 当前操作符和栈顶操作符
  111.         for (int i = 0; i < arr.length; i++) {
  112.             currentOp = arr[i];
  113.             if (isOperator(currentOp)) {// 如果当前字符是运算符
  114.                 if (count > 0) {
  115.                     postfixStack.push(new String(arr, currentIndex, count));// 取两个运算符之间的数字
  116.                 }
  117.                 peekOp = opStack.peek();
  118.                 if (currentOp == ')') {// 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
  119.                     while (opStack.peek() != '(') {
  120.                         postfixStack.push(String.valueOf(opStack.pop()));
  121.                     }
  122.                     opStack.pop();
  123.                 } else {
  124.                     while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
  125.                         postfixStack.push(String.valueOf(opStack.pop()));
  126.                         peekOp = opStack.peek();
  127.                     }
  128.                     opStack.push(currentOp);
  129.                 }
  130.                 count = 0;
  131.                 currentIndex = i + 1;
  132.             } else {
  133.                 count++;
  134.             }
  135.         }
  136.         if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {// 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
  137.             postfixStack.push(new String(arr, currentIndex, count));
  138.         }
  140.         while (opStack.peek() != ',') {
  141.             postfixStack.push(String.valueOf(opStack.pop()));// 将操作符栈中的剩余的元素添加到后缀式栈中
  142.         }
  143.     }
  145.     /**
  146.      * 判断是否为算术符号
  147.      *
  148.      * @param c
  149.      * @return
  150.      */
  151.     private boolean isOperator(char c) {
  152.         return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
  153.     }
  155.     /**
  156.      * 利用ASCII码-40做下标去算术符号优先级
  157.      *
  158.      * @param cur
  159.      * @param peek
  160.      * @return
  161.      */
  162.     public boolean compare(char cur, char peek) {// 如果是peek优先级高于cur，返回true，默认都是peek优先级要低
  163.         boolean result = false;
  164.         if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
  165.             result = true;
  166.         }
  167.         return result;
  168.     }
  170.     /**
  171.      * 按照给定的算术运算符做计算
  172.      *
  173.      * @param firstValue
  174.      * @param secondValue
  175.      * @param currentOp
  176.      * @return
  177.      */
  178.     private String calculate(String firstValue, String secondValue, char currentOp) {
  179.         String result = "";
  180.         switch (currentOp) {
  181.             case '+':
  182.                 result = String.valueOf(ArithHelper.add(firstValue, secondValue));
  183.                 break;
  184.             case '-':
  185.                 result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
  186.                 break;
  187.             case '*':
  188.                 result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
  189.                 break;
  190.             case '/':
  191.                 result = String.valueOf(ArithHelper.div(firstValue, secondValue));
  192.                 break;
  193.         }
  194.         return result;
  195.     }
  196. }

二，ArithHelper — 计算辅助类

  1. package com.test;
  3. /**
  4.  * @Title: sell
  5.  * @Package com.citymine.kafka.kafka
  6.  * @Description:
  7.  * @date 2018/8/2215:53
  8.  */
  9. public class ArithHelper {
  11.     // 默认除法运算精度
  12.     private static final int DEF_DIV_SCALE = 16;
  14.     // 这个类不能实例化
  15.     private ArithHelper() {
  16.     }
  18.     /**
  19.      * 提供精确的加法运算。
  20.      *
  21.      * @param v1 被加数
  22.      * @param v2 加数
  23.      * @return 两个参数的和
  24.      */
  26.     public static double add(double v1, double v2) {
  27.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  28.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  29.         return b1.add(b2).doubleValue();
  30.     }
  32.     public static double add(String v1, String v2) {
  33.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  34.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  35.         return b1.add(b2).doubleValue();
  36.     }
  38.     /**
  39.      * 提供精确的减法运算。
  40.      *
  41.      * @param v1 被减数
  42.      * @param v2 减数
  43.      * @return 两个参数的差
  44.      */
  46.     public static double sub(double v1, double v2) {
  47.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  48.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  49.         return b1.subtract(b2).doubleValue();
  50.     }
  52.     public static double sub(String v1, String v2) {
  53.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  54.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  55.         return b1.subtract(b2).doubleValue();
  56.     }
  58.     /**
  59.      * 提供精确的乘法运算。
  60.      *
  61.      * @param v1
  62.      *            被乘数
  63.      * @param v2
  64.      *            乘数
  65.      * @return 两个参数的积
  66.      */
  68.     public static double mul(double v1, double v2) {
  69.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  70.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  71.         return b1.multiply(b2).doubleValue();
  72.     }
  74.     public static double mul(String v1, String v2) {
  75.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  76.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  77.         return b1.multiply(b2).doubleValue();
  78.     }
  80.     /**
  81.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
  82.      *
  83.      * @param v1
  84.      *            被除数
  85.      * @param v2
  86.      *            除数
  87.      * @return 两个参数的商
  88.      */
  90.     public static double div(double v1, double v2) {
  91.         return div(v1, v2, DEF_DIV_SCALE);
  92.     }
  94.     public static double div(String v1, String v2) {
  95.         java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
  96.         java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
  97.         return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  98.     }
  100.     /**
  101.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
  102.      *
  103.      * @param v1 被除数
  104.      * @param v2 除数
  105.      * @param scale 表示表示需要精确到小数点以后几位。
  106.      * @return 两个参数的商
  107.      */
  109.     public static double div(double v1, double v2, int scale) {
  110.         if (scale < 0) {
  111.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  112.         }
  113.         java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
  114.         java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
  115.         return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  116.     }
  118.     /**
  119.      * 提供精确的小数位四舍五入处理。
  120.      *
  121.      * @param v 需要四舍五入的数字
  122.      * @param scale 小数点后保留几位
  123.      * @return 四舍五入后的结果
  124.      */
  126.     public static double round(double v, int scale) {
  127.         if (scale < 0) {
  128.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  129.         }
  130.         java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
  131.         java.math.BigDecimal one = new java.math.BigDecimal("1");
  132.         return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  133.     }
  135.     public static double round(String v, int scale) {
  136.         if (scale < 0) {
  137.             throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
  138.         }
  139.         java.math.BigDecimal b = new java.math.BigDecimal(v);
  140.         java.math.BigDecimal one = new java.math.BigDecimal("1");
  141.         return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
  142.     }
  143. }

三，CalculateTest — 测试类

  1. package com.test;
  3. /**
  4.  * @author pj_zhang
  5.  * @create 2018-12-07 18:34
  6.  **/
  7. public class CalculateTest {
  8.     public static void main(String[] args) {
  9.         System.out.println(Calculator.conversion("1+(2*3)"));
  10.     }
  11. }

20181207183934376.png

发表评论

表情：
评论列表 （有 0 条评论，401人围观）

还没有评论，来说两句吧...

相关阅读

    相关 简易计算器 Java

    简易计算器 Java 下面是一个用Java编写的简易计算器程序。该程序可以执行基本的算术运算，包括加法、减法、乘法和除法。用户可以通过命令行输入两个操作数和运算符，程序将计算

    电玩女神电玩女神/ 0 赞/ 205 阅读