Java语言实现可简易四则运算的计算器

Java语言实现可简易四则运算的计算器

• 使用的算法：
• 基于双栈的表达式求值算法
  双栈实现表达式的求值是使用栈的一个经典例子，它使用一个栈来保存运算符，另外一个栈来保存操作数。
  算数表达式由括号、运算符和操作数组成，双栈求值实现过程如下：
  1、将操作数压入操作数栈
  2、若是运算符则比较运算符栈顶元素和该运算符的优先级。若前者优先级高，则运算符栈弹出一个运算符，操作数栈弹出两个操作数并进行对应运算，得到结果压入操作数栈；若后者优先级高，则直接压入运算符栈；若两者优先级相等，直接弹出运算符栈顶元素。
  4、最终结果为操作数栈的栈顶元素
• 使用的技术
• Java语言的图形用户界面
• 界面截图：
  
• 点击按钮即可显示，点击“=”可获得结果，若不符合四则运算表达式规则则提示“输入不合法”
• 点击“<-”可返回上一步
• 点击“C”可清除所有内容
• 正确的例子
  
  
• 错误的例子：
  
  
• 源代码：由两个Java源文件：
• Test.java：

package test;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class Test extends JFrame implements ActionListener {
    private JPanel panel1=new JPanel();
    private JPanel panel2=new JPanel();
    private JButton b1=new JButton("1");
    private JButton b2=new JButton("2");
    private JButton b3=new JButton("3");
    private JButton b4=new JButton("4");
    private JButton b5=new JButton("5");
    private JButton b6=new JButton("6");
    private JButton b7=new JButton("7");
    private JButton b8=new JButton("8");
    private JButton b9=new JButton("9");
    private JButton b=new JButton("0");
    private JButton b10=new JButton("+");
    private JButton b11=new JButton("-");
    private JButton b12=new JButton("*");
    private JButton b13=new JButton("/");
    private JButton b14=new JButton(".");
    private JButton b15=new JButton("(");
    private JButton b16=new JButton(")");
    private JButton b17=new JButton("<-");
    private JButton b18=new JButton("=");
    private JButton b19=new JButton("C");
    private String str=null;

    private JTextField field=new JTextField(20);
    private JButton m=new JButton("清零");
   public Test(){
  panel1.add(field);
  add(panel1,BorderLayout.NORTH);
    panel2.setLayout(new GridLayout(4,5));
    panel2.add(b1);
       panel2.add(b7);
       panel2.add(b8);
       panel2.add(b9);
       panel2.add(b10);
       panel2.add(b15);

       panel2.add(b4);
       panel2.add(b5);
       panel2.add(b6);
       panel2.add(b11);
       panel2.add(b16);

       panel2.add(b1);
       panel2.add(b2);
       panel2.add(b3);
       panel2.add(b12);
       panel2.add(b17);

       panel2.add(b);
       panel2.add(b14);
       panel2.add(b18);
       panel2.add(b13);
       panel2.add(b19);
       add(panel2);
       setTitle("计算器");
      setLocation(400,300);
       setVisible(true);
       pack();
       setDefaultCloseOperation(EXIT_ON_CLOSE);
       b1.addActionListener(this);
       b2.addActionListener(this);
       b3.addActionListener(this);
       b4.addActionListener(this);
       b5.addActionListener(this);
       b6.addActionListener(this);
       b7.addActionListener(this);
       b8.addActionListener(this);
       b9.addActionListener(this);
       b10.addActionListener(this);
       b11.addActionListener(this);
       b12.addActionListener(this);
       b13.addActionListener(this);
       b14.addActionListener(this);
       b15.addActionListener(this);
       b16.addActionListener(this);
       b17.addActionListener(this);
       b18.addActionListener(this);
       b19.addActionListener(this);
       b.addActionListener(this);
   }
   public void actionPerformed(ActionEvent event){
       String name=event.getActionCommand();
       if(name=="="){
           String string=field.getText();
           string+="=";
           try{
           double result=Evaluate.Calculate(string);
           field.setText(String.valueOf(result));
           }catch (Exception e){
               field.setText("输入不合法！");
           }
       } else if(name=="<-"){
          field.setText(field.getText().substring(0,field.getText().length()-1));

       } else if(name=="C"){
           field.setText(null);
       } else {
           str=field.getText();
           field.setText(field.getText() + name);
       }
   }
    public static void main(String[] args) {
        new Test();
    }
}

• Evaluate.java

package test;
import java.util.Stack;

public class Evaluate {
    public static char precede(char a,char b){
        if((a=='='&&b=='=')||(a=='(')&&b==')')
            return '=';
        else
        if(a=='('||b=='('||a=='='||((a=='+'||a=='-')&&(b=='*'||b=='/')))
            return '<';
        else
            return '>';
    }
   public static double Operate(double a,char b,double c)  //操作
    {
        if(b=='+')
            return a+c;
       else if(b=='-')
            return a-c;
      else   if(b=='*')
            return a*c;
      else
            return a/c;
    }
    public static double Calculate(String string) {

        Stack<Character> ops = new Stack<>();
        Stack<Double> vals = new Stack<>();
      //  Scanner in = new Scanner(System.in);
        String test = string;
        char[] array = test.toCharArray();

        ops.push('=');
        for (int i = 0; array[i] != '=' || ops.peek() != '='; ) {
            char[] chars = new char[100];
            int t = 0;
            if (array[i] >= '0' && array[i] <= '9' || array[i] == '.') {
                while (array[i] >= '0' && array[i] <= '9' || array[i] == '.') {
                    chars[t] = array[i];
                    t++;
                    i++;
                }
                vals.push(Double.parseDouble(new String(chars)));
                chars = null;
            } else {
                switch (precede(ops.peek(), array[i])) {
                    case '<':
                        ops.push(array[i]);
                        i++;
                        break;
                    case '>':
                        double m = vals.pop();
                        double n = vals.pop();
                        char s = ops.pop();
                        vals.push(Operate(n, s, m));
                        break;
                    case '=':
                        ops.pop();
                        i++;
                        break;
                }
            }
        }
        double result = vals.peek();
//        System.out.printf("%.2f", result);
//        System.out.println();
        return result;
    }
}