Java实现四则混合运算代码示例

使用栈来实现，可以处理运算优先级。

使用自然四则运算表达式即可，如：4+(3*(3-1)+2)/2。无需把表达式先转换为逆波兰等形式。

package com.joshua.cal; 
import java.util.Collections; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.LinkedList; 
import java.util.List; 
import java.util.Map; 
import java.util.Set; 
import java.util.Stack; 
public class Calculator { 
  private final Stack<Double> numStack = new Stack<Double>(); 
  private final Stack<Character> opStack = new Stack<Character>(); 
  private char currentOperator; 
  private char opStackTop; 
  private int i; 
  private String expression; 
  @SuppressWarnings("rawtypes") 
  public void exec(String expression) { 
    try { 
      clean(); 
      if (expression == null || expression.isEmpty()) { 
        throw new IllegalArgumentException("Blank Expression!"); 
      } 
      this.expression = expression; 
      opStack.push(TERMINATE_TOKENS.START_END_MARK); 
      List tokens = TOKENIZER.exec(expression 
          + TERMINATE_TOKENS.START_END_MARK); 
      for (; i < tokens.size(); i++) { 
        final Object token = tokens.get(i); 
        if (token instanceof Double) { 
          processOperand((double) token); 
        } else { 
          processOperator((char) token); 
        } 
      } 
    } catch (Throwable e) { 
      System.err.println(String.format( 
          "Incorret Expression: %s\nError: %s", expression, 
          e.getMessage())); 
    } 
  } 
  private void processOperand(final double operand) { 
    numStack.push(operand); 
  } 
  private void processOperator(final char currentOperator) { 
    this.currentOperator = currentOperator; 
    this.opStackTop = opStack.peek(); 
    char calMode = CALCULATE_MODE.getRule(currentOperator, opStackTop); 
    switch (calMode) { 
    case '>': 
      processStackHigerPriorityOperator(); 
      break; 
    case '<': 
      processStackLowerPriorityOperator(); 
      break; 
    case '=': 
      processStackEqualPriorityOperator(); 
      break; 
    default: 
      break; 
    } 
  } 
  private void processStackLowerPriorityOperator() { 
    opStack.push(currentOperator); 
  } 
  private void processStackHigerPriorityOperator() { 
    numStack.push(CALCULATE.exec(opStack.pop(), numStack.pop(), 
        numStack.pop())); 
    --i; // pointer back to the previous operator. 
  } 
  private void processStackEqualPriorityOperator() { 
    if (TERMINATE_TOKENS.START_END_MARK == currentOperator) { 
      System.out.println(expression + " = " + numStack.peek()); 
    } else if (')' == currentOperator) { 
      opStack.pop(); 
    } 
  } 
  public void clean() { 
    numStack.clear(); 
    opStack.clear(); 
    i = 0; 
  } 
  public static void main(String[] args) { 
    Calculator cal = new Calculator(); 
    cal.exec("4+(3*(3-1)+2)/2"); // = 8 
    cal.exec("4 + (-3 * ( 3 - 1 ) + 2)"); // = 0 
    cal.exec("4 +-/ (-3 * ( 3 - 1 ) + 2)"); // incorrect expression! 
    cal.exec("4.5+(3.2+3)/2"); // = 7.6 
    cal.exec("4.5+(3.2:3)/2"); // incorrect expression! 
    cal.exec("-4.5+(3.2-3)/2"); // = -4.4 
  } 
} 
enum CALCULATE { 
  INSTANCE; 
  public static double exec(final char operator, final double right, 
      final double left) { 
    switch (operator) { 
    case '+': 
      return left + right; 
    case '-': 
      return left - right; 
    case '*': 
      return left * right; 
    case '/': 
      return left / right; 
    default: 
      throw new IllegalArgumentException("Unsupported operator: " 
          + operator); 
    } 
  } 
} 
enum TERMINATE_TOKENS { 
  INSTANCE; 
  public static final char START_END_MARK = '#'; 
  private static final Map<Character, Integer> TOKENs = new HashMap<Character, Integer>(); 
  static { 
    // token, token id 
    TOKENs.put('+', 0); 
    TOKENs.put('-', 1); 
    TOKENs.put('*', 2); 
    TOKENs.put('/', 3); 
    TOKENs.put('(', 4); 
    TOKENs.put(')', 5); 
    TOKENs.put(START_END_MARK, 6); 
  } 
  private static Set<Character> NEGATIVE_NUM_SENSITIVE = new HashSet<Character>(); 
  public static synchronized Set<Character> getNegativeNumSensitiveToken() { 
    if (NEGATIVE_NUM_SENSITIVE.size() == 0) { 
      NEGATIVE_NUM_SENSITIVE.addAll(TOKENs.keySet()); 
      NEGATIVE_NUM_SENSITIVE.remove(')'); 
    } 
    return NEGATIVE_NUM_SENSITIVE; 
  } 
  public static boolean isTerminateToken(final char token) { 
    Set<Character> keys = TOKENs.keySet(); 
    return keys.contains(token); 
  } 
  public static int getTokenId(final char token) { 
    return TOKENs.get(token) == null ? -1 : TOKENs.get(token); 
  } 
  public static int getTokenSize() { 
    return TOKENs.size(); 
  } 
} 
enum CALCULATE_MODE { 
  INSTANCE; 
  private static char[][] RULES = { 
      // + - * / ( ) # 
      { '>', '>', '<', '<', '<', '>', '>' }, // + 
      { '>', '>', '<', '<', '<', '>', '>' }, // - 
      { '>', '>', '>', '>', '<', '>', '>' }, // * 
      { '>', '>', '>', '>', '<', '>', '>' }, // / 
      { '<', '<', '<', '<', '<', '=', 'o' }, // ( 
      { '>', '>', '>', '>', 'o', '>', '>' }, // ) 
      { '<', '<', '<', '<', '<', 'o', '=' }, // # 
  }; 
  static { 
    if (RULES.length != TERMINATE_TOKENS.getTokenSize() || RULES.length < 1 
        || RULES[0].length != TERMINATE_TOKENS.getTokenSize()) { 
      throw new IllegalArgumentException("Rules matrix is incorrect!"); 
    } 
  } 
  public static char getRule(final char currentOperator, final char opStackTop) { 
    try { 
      return RULES[TERMINATE_TOKENS.getTokenId(opStackTop)][TERMINATE_TOKENS 
          .getTokenId(currentOperator)]; 
    } catch (Throwable e) { 
      throw new RuntimeException("No rules were defined for some token!"); 
    } 
  } 
} 
enum TOKENIZER { 
  INSTANCE; 
  private static final StringBuilder BUFFER = new StringBuilder(); 
  private static String clearExpression(String expression) { 
    return expression.replaceAll(" ", ""); 
  } 
  private static Character PREVIOUS_CHAR; 
  private static void clean() { 
    BUFFER.delete(0, BUFFER.length()); 
    PREVIOUS_CHAR = null; 
  } 
  private static boolean processNegativeNumbers(final String exp, 
      final int index) { 
    char c = exp.charAt(index); 
    if (('+' == c || '-' == c) 
        && (PREVIOUS_CHAR == null || TERMINATE_TOKENS 
            .getNegativeNumSensitiveToken().contains(PREVIOUS_CHAR)) 
        && !TERMINATE_TOKENS.isTerminateToken(exp.charAt(index + 1))) { 
      BUFFER.append(c); 
      return true; 
    } 
    return false; 
  } 
  @SuppressWarnings({ "unchecked", "rawtypes" }) 
  public static List<?> exec(final String expression) { 
    clean(); 
    String exp = clearExpression(expression); 
    List result = new LinkedList(); 
    for (int i = 0; i < exp.length(); i++) { 
      char c = exp.charAt(i); 
      if (TERMINATE_TOKENS.isTerminateToken(c)) { 
        if (processNegativeNumbers(exp, i)) 
          continue; 
        if (BUFFER.length() > 0) { 
          result.add(Double.valueOf(BUFFER.toString())); 
          BUFFER.delete(0, BUFFER.length()); 
        } 
        result.add(c); 
      } else { 
        BUFFER.append(c); 
      } 
      PREVIOUS_CHAR = c; 
    } 
    return Collections.unmodifiableList(result); 
  } 
}

输出

4+(3*(3-1)+2)/2 = 8.0
4 + (-3 * ( 3 - 1 ) + 2) = 0.0
4.5+(3.2+3)/2 = 7.6
-4.5+(3.2-3)/2 = -4.4
Incorret Expression: 4 +-/ (-3 * ( 3 - 1 ) + 2)
Error: null
Incorret Expression: 4.5+(3.2:3)/2
Error: For input string: "3.2:3"

总结

以上就是本文关于Java实现四则混合运算代码示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以参阅：大话Java混合运算规则  浅谈Java变量赋值运算符及相关实例  Java大数字运算之BigInteger 等，有什么问题可以随时留言，小编会及时回复大家的。感谢朋友们对网站的支持。

# java  # 四则混合运算  # 混合运算  # java实现随机输出300题四则运算  # java中实现四则运算代码  # java实现任意四则运算表达式求值算法  # 波兰  # 有什么  # 感兴趣  # 朋友们  # 浅谈  # 来实现  # 转换为  # 可以随时  # 小编  # 等形式  # 运算符  # START_END_MARK  # tokens  # push  # TERMINATE_TOKENS  # TOKENIZER  # Object  # token  # size  # instanceof 

相关文章： 南平网站制作公司,2025年南平市事业单位报名时间？  广州网站制作的公司,现在专门做网站的公司有没有哪几家是比较好的，性价比高，模板也多的？  网站建设设计制作营销公司南阳,如何策划设计和建设网站？  Android使用GridView实现日历的简单功能  如何快速搭建响应式可视化网站？  如何在云服务器上快速搭建个人网站？  宁波免费建站如何选择可靠模板与平台？  无锡营销型网站制作公司,无锡网选车牌流程？  ppt制作免费网站有哪些,ppt模板免费下载网站？  如何通过宝塔面板实现本地网站访问？  h5网站制作工具有哪些,h5页面制作工具有哪些？  宝塔面板如何快速创建新站点？  如何批量查询域名的建站时间记录？  制作销售网站教学视频,销售网站有哪些？  图片制作网站免费软件,有没有免费的网站或软件可以将图片批量转为A4大小的pdf？  c# 服务器GC和工作站GC的区别和设置  设计网站制作公司有哪些,制作网页教程？  建站之星ASP如何实现CMS高效搭建与安全管理？  小建面朝正北，A点实际方位是否存在偏差？  如何在Golang中引入测试模块_Golang测试包导入与使用实践  制作网站哪家好,cc、.co、.cm哪个域名更适合做网站？  网站制作网站,深圳做网站哪家比较好？  如何高效生成建站之星成品网站源码？  如何通过商城自助建站源码实现零基础高效建站？  php8.4新语法match怎么用_php8.4match表达式替代switch【方法】  如何高效完成自助建站业务培训？  jQuery 常见小例汇总  C#怎么使用委托和事件 C# delegate与event编程方法  如何快速生成专业多端适配建站电话？  电视网站制作tvbox接口,云海电视怎样自定义添加电视源？  海南网站制作公司有哪些,海口网是哪家的？  建站之星安全性能如何？防护体系能否抵御黑客入侵？  网站制作多少钱一个,建一个论坛网站大约需要多少钱？  百度网页制作网站有哪些,谁能告诉我百度网站是怎么联系？  如何在景安服务器上快速搭建个人网站？  c++ stringstream用法详解_c++字符串与数字转换利器  如何在阿里云通过域名搭建网站？  制作网站的软件下载免费,今日头条开宝箱老是需要下载怎么回事？  邀请函制作网站有哪些,有没有做年会邀请函的网站啊？在线制作，模板很多的那种？  北京网站制作网页,网站升级改版需要多久？  网站制作模板下载什么软件,ppt模板免费下载网站？  如何在Windows环境下新建FTP站点并设置权限？  网站制作中优化长尾关键字挖掘的技巧,建一个视频网站需要多少钱？  Java解压缩zip - 解压缩多个文件或文件夹实例  如何快速完成中国万网建站详细流程？  建站主机是否等同于虚拟主机？  定制建站方案优化指南：企业官网开发与建站费用解析  mc皮肤壁纸制作器,苹果平板怎么设置自己想要的壁纸我的世界？  详解jQuery停止动画——stop()方法的使用  如何安全更换建站之星模板并保留数据？