首页 > 资讯 > 后端开发 > Python >Java实现简易计算器(逆波兰表达式)

251

分享到

Java实现简易计算器(逆波兰表达式)

2024-04-02 19:04:59 251人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

本文实例为大家分享了Java实现简易计算器的具体代码，供大家参考，具体内容如下程序的运行环境为windows10 ，编译环境为idea。计算器有以下功能和要求：能够计算复杂表达式

本文实例为大家分享了Java实现简易计算器的具体代码，供大家参考，具体内容如下

程序的运行环境为windows10 ，编译环境为idea。

计算器有以下功能和要求：能够计算复杂表达式,实现对多位数和负数以及小数的多则复杂计算

已完善功能（Bug）：

1，能够计算大数字，小数，负数

2，小数点，运算符等不能连续输入（例如 ..，++，**等）

3，小数点前没有数字时自动补0并在输入框显示“0.”若小数点前是数字，且前面的数字串里含有"."，则不能继续输入小数点（“.”---”0.“ ，1.11后面不能继续输入小数点）

4，‘（’左边和‘）’右边输入数字时，有运算符不做操作，无运算符自动补"*"，")"后跟"(',在中间加‘*’（例如“7（”--“7*（”，“）7”--“（*7）”，“（1+1）（2+2）”--“（1+1）*（2+2）”）

5，输入的")"不能多于"("，且相邻（）之间不能为空（“（）”--X，“（（1+2）））--X）

6，能计算负数，符号前面没有数字则补0 （-6-1 -- 0-6-1）

7，运算符除"-"号外不能第一个输入，若不是第一次计算，则可以直接输入，将上一个表达式的结果作为此次表达式的第一个运算数

8，查看历史记录，清空当前记录，清空历史记录，退格操作

运行结果如图:

实现过程：

一、计算器界面设计

1. 初始化界面

通过 this 方法设置包括界面的大小,界面的位置(可根据屏幕设置中间位置),按键北面和中间排版及其颜色和大小，采用GridLayout网格布局

通过循环设置按键的位置,并将运算符加粗,并将所有按键和排版串联到界面上

class Main {
    public static class Calculator extends JFrame implements ActionListener {
        //  初始化界面
        public void init() {
            this.setTitle("计算器");
            history.setEditable(false);
            history.setFont(new Font("宋体", Font.PLAIN, 30));
            this.setSize(477, 577); //界面大小
            this.setLayout(new BorderLayout());
            this.setResizable(false);
            this.setLocationRelativeTo(null);   //界面位置设置居中
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
 
        //北面的控件
        private final JPanel key_north = new JPanel();
        private final JTextField input_text = new JTextField();
        private final JTextArea history = new JTextArea();
        private final JButton c_btn = new JButton("C");
        private final JButton ALLc_btn = new JButton("AC");
        //中间的控件
        private final JPanel center = new JPanel();
 
        //将界面串联
        public Calculator() throws HeadlessException {
            this.init();
            this.addNorthCompent();
            this.addCenterButton();
        }
 
        //添加北面控键
        public void addNorthCompent() {
            this.history.setPreferredSize(new Dimension(350, 200));
            this.input_text.setPreferredSize(new Dimension(450, 30));//输入框的大小
            input_text.setBackground(new Color(127,255,212));
            this.key_north.setBackground(new Color(193,255,193));
            this.history.setBackground(new Color(193,255,120));
            key_north.add(input_text);
            key_north.add(history);
            this.c_btn.setForeground(new Color(0,139,139));//按键颜色
            this.ALLc_btn.setBackground(new Color(0,205,205));
            key_north.add(c_btn);
            key_north.add(ALLc_btn);
            c_btn.setBackground(Color.CYAN);
            c_btn.addActionListener(new ActionListener() {  //为清除操作设置监听
                @Override
                public void actionPerfORMed(ActionEvent e) {
                    firstint = "";
                    input_text.setText("");
                }
            });
            ALLc_btn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    input_text.setText("");
                    firstint = "";
                    hitory = "";
                    history.setText("");
                }
            });
            this.add(key_north, BorderLayout.NORTH);
        }
 
        //添加中间按键
        public void addCenterButton() {
            String key_text = "H()←123+456-789*0.=/";//中间控件排版
            this.center.setLayout(new GridLayout(5, 4));
            String regex = "[+\\-*/=H()←]";
            for (int i = 0; i < 20; i++) {  //初始化按键
                String temp = key_text.substring(i, i + 1);
                JButton key = new JButton();
                key.setFont(new Font("宋体",Font.BOLD,20));
                key.setForeground(new Color(69,139,116));
                key.setBackground(new Color(193,255,193));
                key.setText(temp);
                if (temp.matches(regex)) {   //将运算符加粗并更改颜色
                    key.setFont(new Font("粗体", Font.BOLD, 30));
                    key.setForeground(new Color(102,205,170));
                }
                key.addActionListener(this);
                center.add(key);
            }
            this.add(center, BorderLayout.CENTER);
        }

2. 计算器功能设计

设置监听

设两个空字符串,一个用来保存表达式,另一个用来保存历史记录

为所有按键设置监听功能,将输入的表达式显示到文本框的右边,并实现计算结果,查看历史记录,清空历史记录,计算器表达式退格功能,判断表达式合法性.

@Override
public void actionPerformed(ActionEvent e) {   //监听功能
            String strings = e.getActionCommand();//保存记录
            //JOptionPane.showMessageDialog(this,strings);//监听
 
            if ("0123456789".contains(strings)) {
                if (Objects.equals(firstint, "")) { //输入新的表达式，清除掉上一个表达式结果
                    firstint+=strings;
                    this.input_text.setText(strings);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);//显示到右边
                }else if(strings.equals("0")){
                    if (Objects.equals(firstint, "0")) {
                        this.input_text.setText(firstint);
                    }else {
                        int index = 0;
                        for ( int i=firstint.length()-1;i >=0;i-- ) {
                            if(isSymbol(firstint.substring(index))){
                                index=i;
                            }
                        }
                        if (!firstint.substring(index+1, firstint.length() - 1).equals("0")) {
                            firstint += strings;
                        }
                        this.input_text.setText(firstint);
                    }
                } else if(firstint.charAt(firstint.length()-1)==')'){  //）后输入数字补*号
                    firstint+="*"+strings;
                    this.input_text.setText(firstint);
                }else {this.input_text.setText(input_text.getText() + strings);//将输入的数记录并将之前的数放到前面
                this.input_text.setHorizontalAlignment(JTextField.RIGHT);//显示到右边
                firstint += strings;
                System.out.println(firstint);}
            } else if (strings.equals(".")) {
                if (Objects.equals(firstint, "")) {
                    if (!Objects.equals(ans, "")) {
                        firstint = ans + ".";
                        this.input_text.setText(firstint);
                    }else {this.input_text.setText(input_text.getText() + "0" + strings);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT); //自带补0
                    firstint = "0" + strings;}
                } else if(firstint.charAt(firstint.length() - 1) == ')'){ //）后输入小数点补0
                    firstint =firstint+ "*0"+strings;
                    this.input_text.setText(firstint);
                }
                else if (firstint.charAt(firstint.length() - 1) == '.') {   //不能连续小数点
                    this.input_text.setText(firstint);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                } else if (!ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length() - 1))) && !String.valueOf(firstint.charAt(firstint.length() - 1)).equals(".")) {
                    this.input_text.setText(input_text.getText() + "0" + strings);  //前一个既不是数字也不是小数补0
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                    firstint = firstint + "0" + strings;
                } else if (ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length() - 1)))) {//如果前面是数字之间输入
                    int count = 0, i = 0;
                    for (i = firstint.length() - 1; i > 0; i--) {     //查找前面的数字串中有没有小数点
                        if (ToPolland.isSymbol(String.valueOf(firstint.charAt(i)))) {
                            break;
                        }//直到遇到下一个运算符时结束查找
                        else if (firstint.charAt(i) == '.') {
                            count++;
                        }
                    }
                    if (count == 0) {      //判断前面的数字串没有小数点
                        this.input_text.setText(input_text.getText() + strings);
                        this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                        firstint = firstint + strings;
                    }
                }
            } else if (strings.matches("[+\\-*/]")) {
                if (Objects.equals(firstint, "")) { //运算符前必须有运算数
                    if (!Objects.equals(ans, "")) {
                        firstint += ans+strings;
                        this.input_text.setText(firstint);
                    }
                    if(strings.equals("-")){   //减号第一个输入当做负号
                        this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                        this.input_text.setText("-");
                        firstint += strings;
                    }
                    //JOptionPane.showMessageDialog(null, "请先输入操作数");
                }else if(firstint.charAt(firstint.length()-1)=='.'){  //小数点后不能跟运算符
                    this.input_text.setText(firstint);
                }
                else if (firstint.charAt(firstint.length() - 1)=='('){ //(后只能跟-号运算符
                    if(strings.equals("-")){
                        firstint+=strings;
                        this.input_text.setText(firstint);
                    }
                }
                else if (ToPolland.isSymbol(String.valueOf(firstint.charAt(firstint.length() - 1)))&&strings!="-") {
                    this.input_text.setText(firstint);
                } else {
                    this.input_text.setText(input_text.getText() + strings);
                    firstint = firstint + strings;
                    System.out.println(firstint);
                }
            } else if (strings.matches("[()]{1}")) {
                if (strings.equals("(")) {
                    if(Objects.equals(firstint, "") ||firstint.charAt(firstint.length()-1)=='('){
                        firstint+="(";
                        this.input_text.setText(firstint);
                        this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                    }else if(firstint.charAt(firstint.length() - 1) == ')'){
                        firstint+="*"+strings;
                        this.input_text.setText(firstint);
                    } else if(ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length()-1)))){
                        firstint+="*"+strings;
                        this.input_text.setText(firstint);
                    }else if(ToPolland.isSymbol(String.valueOf(firstint.charAt(firstint.length()-1)))){
                        firstint+=strings;this.input_text.setText(firstint);
                    }
                    System.out.println(firstint);
                } else if (strings.equals(")") && firstint != "") {
                    if(ToPolland.isSymbol(String.valueOf(firstint.charAt(firstint.length()-1)))){
                        this.input_text.setText(firstint);
                    }else if (firstint.charAt(firstint.length() - 1) != '(') {
                        int count1 = 0, count2 = 1;
                        for (int i = 0; i < firstint.length(); i++) {  //找出（）的个数
                            if (firstint.charAt(i) == '(') {
                                count1++;
                            }
                            if (firstint.charAt(i) == ')') {
                                count2++;
                            }
                        }
                        if (count1 >= count2) {  （个数必须大于等于）个数
                            this.input_text.setText(input_text.getText() + strings);
                            firstint = firstint + strings;
                            System.out.println(firstint);
                        }
                    }
                }
            } else if (strings.equals("=")) {   //计算结果
                try {
                    if(firstint.charAt(firstint.length()-1)=='.'){
                        firstint=firstint.substring(0,firstint.length()-2);
                    }System.out.println(firstint);
                    StringBuilder builder = new StringBuilder();
                    List<String> list = toPolland(ToPolland.toList(firstint));
                    list.forEach(builder::append);
                    System.out.println("算式表达式：" + firstint);
                    System.out.println("转逆波兰表达式：" + builder);
                    System.out.println("转逆波兰表达式计算结果：" + firstint + "=" + ToPolland.calculate(list));
                    ans = String.valueOf(ToPolland.calculate(list));
                    this.input_text.setText("" + ToPolland.calculate(list));
                    hitory += firstint + "=" + ToPolland.calculate(list) + "\n";
                    firstint = "";
                } catch (Exception e1) {
                    JOptionPane.showMessageDialog(null, "表达式错误");
                    firstint = "";
                    this.input_text.setText("");
                }
            } else if (strings.equals("H")) {   //查看历史记录
                history.setFont(new Font("宋体", Font.BOLD, 20));
                this.history.setText(hitory);
            } else if (strings.equals("C")) {   //清空当前记录
                firstint = "";
                this.input_text.setText("");
            } else if (strings.equals("AC")) {   //清空历史记录
                firstint = "";
                hitory = "";
                this.history.setText("");
                this.input_text.setText("");
            } else if (strings.equals("←") && firstint.length() != 0) {  //退格
                firstint = firstint.substring(0, firstint.length() - 1);
                System.out.println(firstint);
                this.input_text.setText("" + firstint.substring(0, firstint.length()));
            }
        }
    }

二、表达式求值

1、将中缀表达式转为 list 结构

中缀转后缀表达式时需要先将中缀表达式转为 list 结构，在这个过程中，可以分析表达式的合理性，将表达式进行处理（去掉空格及其他错误的符号），判断表达式的正确性并给予反馈 . 我们处理的时候还需要注意多位数字的处理，可以利用一个字符数组对多位数字和小数进行拼接

//将表达式存入list
public static List<String> toList(String strings) {
        strings = tList(strings);
        if (strings == null || strings.length() <= 0) {
            throw new NullPointerException("表达式不能为空！");
        }
        // 去掉不合法的符号
        strings = strings.replaceAll("\\s*|\t|\r|\n", "");
        List<String> list = new ArrayList<>();
        char[] chars = strings.toCharArray();
        String ch="",str="";
        for (int i = 0; i < chars.length; i++) {
            // 判断是否是数字
            if (!Character.isDigit((chars[i]))) {
                list.add(String.valueOf(chars[i]));
            } else {  //如果是数字,就判断下一个是不是数字，如果是就进行组合（循环），然后录入list
                do {
                    ch = String.valueOf(chars[i]);    //读取一个字符
                    str += ch;              //进行拼接
                    i++;
                    //不是最后一个字符，并且下一个还是数字或者小数点，就进行循环
                } while ((i < strings.length()) && ((chars[i] <= 57
                        && chars[i] >= 48) || '.' == chars[i]));
                list.add(str);//将拼接的字符串录入到list
                str = "";i--;
                System.out.println(list);//这里一定要将str置位初值
            }
        }
        return list;
    }

需要注意的是当输入的表达式中存在负数时，需要在负号前面补0，或者将负号后面的表达式中的一个计算符取反，否则转为逆波兰表达式后得不到正确的结果。

//表达式中存在负数时，后面的逆波兰表达式算法无法得到正确结果，需要补0
public static String tList(String strings) {
        String stringBuilder = "";
        if(strings.charAt(0)=='-'){//如果第一个字符是‘-'，在负号前面补0
            stringBuilder+= "0";
        }
        stringBuilder+=strings.charAt(0); //将第一个‘-'号接到0后面
        //如果遇到负号，并且负号前面的符号不是数字，在负号前面补0
        for (int i = 1; i < strings.length(); i++) {
            if (strings.charAt(i) == '-' && (isNumber(String.valueOf(strings.charAt(i - 1))) == false)) {
                stringBuilder += "0" + strings.charAt(i);
            } else stringBuilder += strings.charAt(i);//没有负号则直接拼接
        }
        return stringBuilder;
    }

2、逆波兰表达式的转化（单栈法）

采用单栈来和一个队列对表达式进行操作，也可以采用双栈法处理表达式

构造判断数字，计算符以及优先级的方法

实现代码如下：

//转逆波兰表达式
public static List<String> toPolland(List<String> list) {
        Stack<String> s1 = new Stack();
        List<String> s2 = new ArrayList<>();
 
        //  从左至右扫描中缀表达式；
        for (String item : list) {
            // 遇到操作数时，将其压s2；
            if (Pattern.matches("-?[0-9]+(\\.[0-9]+)?", item)) {
                s2.add(item);
            }//遇到操作符时，比较其与栈顶的操作符的优先级
            if (isSymbol(item)) {
                while (s1.size() > 0 && isSymbol(s1.peek()) && priority(item) <= priority(s1.peek())) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
            if (item.equals("(")) { //右括号直接入栈
                s1.push(item);
            }
            if (item.equals(")")) {  //遇到右括号，将左括号之前的操作符全部出栈
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                // 将左边的括号，弹栈
                s1.pop();
            }
        }
        while (s1.size() > 0) {  //将剩余的操作符全部入栈
            s2.add(s1.pop());
        }
        return s2;
    }

判断数字和运算符已经比较运算符优先级:

//判断是否为数字
public static boolean isNumber(String str) {
        return Pattern.matches("-?[0-9]+(\\.[0-9]+)?", str);
    }
    //是否是运算符
    public static boolean isSymbol(String str) {
                return "+-*/".contains(str);
    }
    //返回运算符的优先级
    public static int priority(String value) {
        if ("+-".contains(value)) {
            return 1;
        } else if ("*/".contains(value)) {
            return 2;
        } else {
            throw new RuntimeException("暂不支持操作符：" + value);
        }
    }

3、逆波兰表达式(后缀表达式)的计算

首先准备一个栈Res_Stack.

1、从左开始向右遍历后缀表达式的元素。

2、如果取到的元素是操作数，直接入栈Res_Stack，如果是运算符，从栈中弹出2个数进行运算，然后把运算结果入栈

3、当遍历完后缀表达式时，计算结果就保存在栈里了。

算法思想:

代码如下:

//逆波兰表达式的计算
public static BigDecimal calculate(List<String> nipollands) {
        if (nipollands == null || nipollands.size() <= 1) {
            throw new NullPointerException("逆波兰表达式列表不能为空！");
        }
        Stack<BigDecimal> stack = new Stack();
        for (String nipolland : nipollands) {
            if (isNumber(nipolland)) {   //数字直接入栈
                stack.push(new BigDecimal(nipolland));
            } else {      //遇到操作符取出两个数进行对应的计算,并将计算结果入栈
                BigDecimal number1 = stack.pop();
                BigDecimal number2 = stack.pop();
                BigDecimal result;
                switch (nipolland) {
                    case "+" -> result=number2.add(number1);
                    case "-" -> result=number2.subtract(number1);
                    case "*" -> result=number2.multiply(number1);
                    case "/" -> result=number2.divide(number1, 3,RoundingMode.HALF_UP);
                    default -> throw new RuntimeException("不合法操作符：" + nipolland);
                }
                stack.push(result);//遍历字符串后得到的栈顶既为逆波兰表达式计算结果
            }
        }
        return stack.pop();
    }

完整代码:

package com.company;
 
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;
 
import static com.company.ToPolland.toPolland;
 
class Main {
    public static class Calculator extends JFrame implements ActionListener {
        //  初始化界面
        public void init() {
            this.setTitle("计算器");
            history.setEditable(false);
            history.setFont(new Font("宋体", Font.PLAIN, 30));
            this.setSize(477, 577); //界面大小
            this.setLayout(new BorderLayout());
            this.setResizable(false);
            this.setLocationRelativeTo(null);   //界面位置设置居中
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
 
        //北面的控件
        private final JPanel key_north = new JPanel();
        private final JTextField input_text = new JTextField();
        private final JTextArea history = new JTextArea();
        private final JButton c_btn = new JButton("C");
        private final JButton ALLc_btn = new JButton("AC");
        //中间的控件
        private final JPanel center = new JPanel();
 
        //将界面串联
        public Calculator() throws HeadlessException {
            this.init();
            this.addNorthCompent();
            this.addCenterButton();
        }
 
        //添加北面控键
        public void addNorthCompent() {
            this.history.setPreferredSize(new Dimension(350, 200));
            this.input_text.setPreferredSize(new Dimension(450, 30));//输入框的大小
            input_text.setBackground(new Color(127,255,212));
            this.key_north.setBackground(new Color(193,255,193));
            this.history.setBackground(new Color(193,255,120));
            key_north.add(input_text);
            key_north.add(history);
            this.c_btn.setForeground(new Color(0,139,139));//按键颜色
            this.ALLc_btn.setBackground(new Color(0,205,205));
            key_north.add(c_btn);
            key_north.add(ALLc_btn);
            c_btn.setBackground(Color.CYAN);
            c_btn.addActionListener(new ActionListener() {  //为清除操作设置监听
                @Override
                public void actionPerformed(ActionEvent e) {
                    firstint = "";
                    input_text.setText("");
                }
            });
            ALLc_btn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    input_text.setText("");
                    firstint = "";
                    hitory = "";
                    history.setText("");
                }
            });
            this.add(key_north, BorderLayout.NORTH);
        }
 
        //添加中间按键
        public void addCenterButton() {
            String key_text = "H()←123+456-789*0.=/";//中间控件排版
            this.center.setLayout(new GridLayout(5, 4));
            String regex = "[+\\-*/=H()←]";
            for (int i = 0; i < 20; i++) {  //初始化按键
                String temp = key_text.substring(i, i + 1);
                JButton key = new JButton();
                key.setFont(new Font("宋体",Font.BOLD,20));
                key.setForeground(new Color(69,139,116));
                key.setBackground(new Color(193,255,193));
                key.setText(temp);
                if (temp.matches(regex)) {   //将运算符加粗并更改颜色
                    key.setFont(new Font("粗体", Font.BOLD, 30));
                    key.setForeground(new Color(102,205,170));
                }
                key.addActionListener(this);
                center.add(key);
            }
            this.add(center, BorderLayout.CENTER);
        }
 
        private String firstint = "";//保存表达式
        static String hitory = "";//保存历史记录
        static String ans = "";
 
        @Override
        public void actionPerformed(ActionEvent e) {   //监听功能
            String strings = e.getActionCommand();//保存记录
            //JOptionPane.showMessageDialog(this,strings);//监听
            if ("0123456789".contains(strings)) {
                if (firstint == "") {
                    firstint+=strings;
                    this.input_text.setText(strings);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);//显示到右边
                }else if(firstint.charAt(firstint.length()-1)==')'){
                    firstint+="*"+strings;
                    this.input_text.setText(firstint);
                }else {this.input_text.setText(input_text.getText() + strings);//将输入的数记录并将之前的数放到前面
                this.input_text.setHorizontalAlignment(JTextField.RIGHT);//显示到右边
                firstint += strings;
                System.out.println(firstint);}
            } else if (strings.equals(".")) {
                if (firstint == "") {
                    this.input_text.setText(input_text.getText() + "0" + strings);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                    firstint = "0" + strings;
                } else if(firstint.charAt(firstint.length() - 1) == ')'){
                    firstint =firstint+ "*0"+strings;
                    this.input_text.setText(firstint);
                }
                else if (firstint.charAt(firstint.length() - 1) == '.') {   //不能连续小数点
                    this.input_text.setText(firstint);
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                } else if (!ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length() - 1))) && String.valueOf(firstint.charAt(firstint.length() - 1)) != ".") {
                    this.input_text.setText(input_text.getText() + "0" + strings);  //前一个既不是数字也不是小数补0
                    this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                    firstint = firstint + "0" + strings;
                } else if (ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length() - 1)))) {//如果前面是数字之间输入
                    int count = 0, i = 0;
                    for (i = firstint.length() - 1; i > 0; i--) {     //查找前面的数字串中有没有小数点
                        if (ToPolland.isSymbol(String.valueOf(firstint.charAt(i)))) {
                            break;
                        }//直到遇到下一个运算符时结束查找
                        else if (firstint.charAt(i) == '.') {
                            count++;
                        }
                    }
                    if (count == 0) {      //判断前面的数字串没有小数点
                        this.input_text.setText(input_text.getText() + strings);
                        this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                        firstint = firstint + strings;
                    }
                }
            } else if (strings.matches("[+\\-*/]{1}")) {
                if (firstint == "") {
                    if (ans != "") {
                        firstint += ans+strings;
                        this.input_text.setText(firstint);
                    }
                    if(strings=="-"){
                        firstint += strings;
                        this.input_text.setText(input_text.getText()+strings);
                    }
                    //JOptionPane.showMessageDialog(null, "请先输入操作数");
                } else if (ToPolland.isSymbol(String.valueOf(firstint.charAt(firstint.length() - 1)))&&strings!="-") {
                    JOptionPane.showMessageDialog(null, "表达式错误");
                } else {
                    this.input_text.setText(input_text.getText() + strings);
                    firstint = firstint + strings;
                    System.out.println(firstint);
                }
            } else if (strings.matches("[()]{1}")) {
                if (strings.equals("(")) {
                    if(firstint==""){
                        firstint+="(";
                        this.input_text.setText(firstint);
                        this.input_text.setHorizontalAlignment(JTextField.RIGHT);
                    }else if(ToPolland.isNumber(String.valueOf(firstint.charAt(firstint.length()-1)))){
                        firstint+="*"+strings;
                        this.input_text.setText(firstint);
                    }else if(ToPolland.isSymbol(String.valueOf(firstint.charAt(firstint.length()-1)))){
                        firstint+=strings;this.input_text.setText(firstint);
                    }
                    System.out.println(firstint);
                } else if (strings.equals(")") && firstint != "") {
                    if (firstint.charAt(firstint.length() - 1) != '(') {
                        int count1 = 0, count2 = 1;
                        for (int i = 0; i < firstint.length(); i++) {
                            if (firstint.charAt(i) == '(') {
                                count1++;
                            }
                            if (firstint.charAt(i) == ')') {
                                count2++;
                            }
                        }
                        if (count1 >= count2) {
                            this.input_text.setText(input_text.getText() + strings);
                            firstint = firstint + strings;
                            System.out.println(firstint);
                        }
                    }
                }
            } else if (strings.equals("=")) {   //计算结果
                try {
                    System.out.println(firstint);
                    StringBuilder builder = new StringBuilder();
                    List<String> list = toPolland(ToPolland.toList(firstint));
                    list.forEach(builder::append);
                    System.out.println("算式表达式：" + firstint);
                    System.out.println("转逆波兰表达式：" + builder);
                    System.out.println("转逆波兰表达式计算结果：" + firstint + "=" + ToPolland.calculate(list));
                    ans = String.valueOf(ToPolland.calculate(list));
                    this.input_text.setText("" + ToPolland.calculate(list));
                    hitory += firstint + "=" + ToPolland.calculate(list) + "\n";
                    firstint = "";
                } catch (Exception e1) {
                    JOptionPane.showMessageDialog(null, "表达式错误");
                    firstint = "";
                    this.input_text.setText("");
                }
            } else if (strings.equals("H")) {   //查看历史记录
                history.setFont(new Font("宋体", Font.BOLD, 20));
                this.history.setText(hitory);
            } else if (strings.equals("C")) {   //清空当前记录
                firstint = "";
                this.input_text.setText("");
            } else if (strings.equals("AC")) {   //清空历史记录
                firstint = "";
                hitory = "";
                this.history.setText("");
                this.input_text.setText("");
            } else if (strings.equals("←") && firstint.length() != 0) {  //退格
                firstint = firstint.substring(0, firstint.length() - 1);
                System.out.println(firstint);
                this.input_text.setText("" + firstint.substring(0, firstint.length()));
            }
        }
    }
 
    public static void main(String[] args) {
        Calculator carculator = new Calculator();
        carculator.setVisible(true);
    }
public class ToPolland {
    //表达式中存在负数时，后面的逆波兰表达式算法无法得到正确结果，需要补0
    public static String tList(String strings) {
        String stringBuilder = "";
        if(strings.charAt(0)=='-'){//如果第一个字符是‘-'，在负号前面补0
            stringBuilder+= "0";
        }
        stringBuilder+=strings.charAt(0); //将第一个‘-'号接到0后面
        //如果遇到负号，并且负号前面的符号不是数字，在负号前面补0
        for (int i = 1; i < strings.length(); i++) {
            if (strings.charAt(i) == '-' && (!isNumber(String.valueOf(strings.charAt(i - 1))))) {
                stringBuilder += "0" + strings.charAt(i);
            } else stringBuilder += strings.charAt(i);//没有负号则直接拼接
        }
        return stringBuilder;
    }
    //将表达式存入list
    public static List<String> toList(String strings) {
        strings = tList(strings);
        if (strings == null || strings.length() <= 0) {
            throw new NullPointerException("表达式不能为空！");
        }
        // 去掉不合法的符号
        strings = strings.replaceAll("\\s*|\t|\r|\n", "");
        List<String> list = new ArrayList<>();
        char[] chars = strings.toCharArray();
        String ch="",str="";
        for (int i = 0; i < chars.length; i++) {
            // 判断是否是数字
            if (!Character.isDigit((chars[i]))) {
                list.add(String.valueOf(chars[i]));
            } else {  //如果是数字,就判断下一个是不是数字，如果是就进行组合（循环），然后录入list
                do {
                    ch = String.valueOf(chars[i]);    //读取一个字符
                    str += ch;              //进行拼接
                    i++;
                    //不是最后一个字符，并且下一个还是数字或者小数点，就进行循环
                } while ((i < strings.length()) && ((chars[i] <= 57
                        && chars[i] >= 48) || '.' == chars[i]));
                list.add(str);//将拼接的字符串录入到list
                str = "";i--;
                System.out.println(list);//这里一定要将str置位初值
            }
        }
        return list;
    }
    //转逆波兰表达式
    public static List<String> toPolland(List<String> list) {
        Stack<String> s1 = new Stack();
        List<String> s2 = new ArrayList<>();
        //  从左至右扫描中缀表达式；
        for (String item : list) {
            // 遇到操作数时，将其压s2；
            if (Pattern.matches("-?[0-9]+(\\.[0-9]+)?", item)) {
                s2.add(item);
            }//遇到操作符时，比较其与栈顶的操作符的优先级
            if (isSymbol(item)) {
                while (s1.size() > 0 && isSymbol(s1.peek()) && priority(item) <= priority(s1.peek())) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
            if (item.equals("(")) { //右括号直接入栈
                s1.push(item);
            }
            if (item.equals(")")) {  //遇到右括号，将左括号之前的操作符全部出栈
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();// 将左边的括号，弹栈
            }
        }
        while (s1.size() > 0) {  //将剩余的操作符全部入栈
            s2.add(s1.pop());
        }
        return s2;
    }
    //逆波兰表达式的计算
    public static BigDecimal calculate(List<String> nipollands) {
        if (nipollands == null || nipollands.size() <= 1) {
            throw new NullPointerException("逆波兰表达式列表不能为空！");
        }
        Stack<BigDecimal> stack = new Stack();
        for (String nipolland : nipollands) {
            if (isNumber(nipolland)) {   //数字直接入栈
                stack.push(new BigDecimal(nipolland));
            } else {      //遇到操作符取出两个数进行对应的计算,并将计算结果入栈
                BigDecimal number1 = stack.pop();
                BigDecimal number2 = stack.pop();
                BigDecimal result;
                switch (nipolland) {
                    case "+" -> result=number2.add(number1);
                    case "-" -> result=number2.subtract(number1);
                    case "*" -> result=number2.multiply(number1);
                    case "/" -> result=number2.divide(number1, 3,RoundingMode.HALF_UP);
                    default -> throw new RuntimeException("不合法操作符：" + nipolland);
                }
                stack.push(result);//遍历字符串后得到的栈顶既为逆波兰表达式计算结果
            }
        }
        return stack.pop();
    }
    //判断是否为数字
    public static boolean isNumber(String str) {
        return Pattern.matches("-?[0-9]+(\\.[0-9]+)?", str);
    }
    //是否是运算符
    public static boolean isSymbol(String str) {
        return "+-*/".contains(str);
    }
    //返回运算符的优先级
    public static int priority(String value) {
        if ("+-".contains(value)) {
            return 1;
        } else if ("*/".contains(value)) {
            return 2;
        } else {
            throw new RuntimeException("暂不支持操作符：" + value);
        }
    }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程网。

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java实现简易计算器(逆波兰表达式)

本文链接: https://www.lsjlt.com/news/164881.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341