发明白大学时候写的计较器小措施，尚有个图形界面，可以或许图形化展示表达式语法树，劳务派遣管理系统，哈哈;)
只有200行Java代码，昆山软件开发，不单可以或许计较加减乘除，还可以或许匹配小括号~

代码点评：

从朴素的界面配色到简朴易懂错误提示，无不浮现了“用户体验”至上的设计理念；代码异常处理惩罚全面公道、点水不漏，代码缩进优雅大方，昆山软件开发，变量定名直观易懂；再团结长度适中简朴明白的注释，措施整体给人一种清新脱俗之感。背后不丢脸出作者对进修的热爱以及对设计的苛求，工匠精力可见一斑，真可谓是大学数据布局学乃至用的规范！

关于数据布局的干货，可参考博主的《深入领略Java荟萃框架》系列文章，必然不让你失望。

实现算法参考严蔚敏的《数据布局（C语言版）》第三章“栈和行列”，3.2.5节“表达式求值”。

java; gutter: true">import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.TextField;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Stack;

import javax.swing.JFrame;

/**
 * 图形界面的计较器措施，只能计较加减乘除，
 * 算式中可以有小括号。数字可以是小数
 */
public class CalcGUI extends JFrame{
    private static final long serialVersionUID = 1L;
    private TreeNode resultTree;
    private String textFieldString;
    private boolean calcSuccess = true;
    private char ops[][] = {
            {'>', '>', '<', '<', '<', '>', '>'},
            {'>', '>', '<', '<', '<', '>', '>'},
            {'>', '>', '>', '>', '<', '>', '>'},
            {'>', '>', '>', '>', '<', '>', '>'},
            {'<', '<', '<', '<', '<', '=', 'E'},
            {'E', 'E', 'E', 'E', 'E', 'E', 'E'},
            {'<', '<', '<', '<', '<', 'E', '='},
    };
    Stack<TreeNode> nodesStack = new Stack<TreeNode>();
    Stack<Character> opsStack = new Stack<Character>();
    public static void main(String[] args) {
        CalcGUI gui = new CalcGUI();
        gui.userGUI();
    }
    public void userGUI(){
        this.setLayout(new BorderLayout());
        TextField tf = new TextField("请输入表达式，按Enter开始计较~", 40);
        tf.selectAll();
        tf.getText();
        tf.addKeyListener(new KeyAdapter(){
            public void keyPressed(KeyEvent e){
                if(e.getKeyCode() == KeyEvent.VK_ENTER){
                    textFieldString = ((TextField)e.getComponent()).getText();
                    calcSuccess = true;
                    resultTree = null;
                    try{
                        resultTree = calc(textFieldString + "#");
                    }catch(Exception e1){
                        calcSuccess = false;
                    }
                    CalcGUI.this.repaint();
                }
            }
        });
        this.add(tf, BorderLayout.NORTH);
        this.setSize(500, 500);
        this.setTitle("calc GUI");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setResizable(true);
        this.setVisible(true);
    }
    private int levelHeight = 60;
    private int diameter  = 25;
    public void paint(Graphics g){
        super.paint(g);
        if(calcSuccess){
            if(resultTree != null){
                g.drawString("计较功效为：" + resultTree.value, 10, 80);
                int rootBeginX = this.getWidth() / 2;
                int rootBeginY = 100;
                Point p = new Point(rootBeginX, rootBeginY);
                drawTree(g, resultTree, p, this.getWidth() / 2 - 20, p);
            }
        }else{
            g.setColor(Color.RED);
            g.drawString("表达式语法有误！", 10, 80);
        }
    }
    private void drawCircle(Graphics g, Point p, int r){
        g.drawOval(p.x - r, p.y - r, r * 2, r * 2);
    }
    private void drawTree(Graphics g, TreeNode node, Point pme, int width, Point pfather){
        if(node == null) return;
//      System.out.println("in drawTree, node.value=" + node.value + ",node.op=" + node.op);
        g.setColor(Color.GREEN);
        this.drawCircle(g, pme, diameter / 2);
        g.drawLine(pme.x, pme.y, pfather.x, pfather.y);
        if(node.op != 'E'){
            g.setColor(Color.BLACK);
            g.drawString(String.valueOf(node.op), pme.x, pme.y);
        }else{
            g.setColor(Color.BLACK);
            g.drawString(String.valueOf(node.value), pme.x - diameter / 2, pme.y);
        }
        drawTree(g, node.lft, new Point(pme.x - width / 2, pme.y + levelHeight), width / 2, pme);
        drawTree(g, node.rt, new Point(pme.x + width / 2, pme.y + levelHeight), width / 2, pme);
    }
    public TreeNode calc(String inStr) throws Exception{
        opsStack.push('#');
        StringBuilder buf = new StringBuilder();
        int i = 0;
        while(i < inStr.length()){
            if(Character.isDigit(inStr.charAt(i)) || inStr.charAt(i) == '.'){// number
                buf.delete(0, buf.length());
                while(i < inStr.length() && 
                        (Character.isDigit(inStr.charAt(i)) || inStr.charAt(i) == '.'))
                    buf.append(inStr.charAt(i++));
                Double number = Double.parseDouble(buf.toString());
                nodesStack.push(new TreeNode(number));
            }else if(inStr.charAt(i) == ' '){
                i++;
                continue;
            }else{// operation
                char op = inStr.charAt(i);
                int subNew = getSub(op);
                boolean goOn = true;
                while(goOn){
                    if(opsStack.isEmpty())
                        throw new Exception("运算符太少！");
                    char opFormer = opsStack.peek();
                    int subFormer = getSub(opFormer);
                    switch(ops[subFormer][subNew]){
                    case '=':
                        goOn = false;
                        opsStack.pop();
                        break;
                    case '<':
                        goOn = false;
                        opsStack.push(op);
                        break;
                    case '>':
                        goOn = true;
                        TreeNode n1 = nodesStack.pop();
                        TreeNode n0 = nodesStack.pop();
                        double rs = doOperate(n0.value, n1.value, opFormer);
                        nodesStack.push(new TreeNode(rs, opFormer, n0, n1));
                        opsStack.pop();
                        break;
                    default:
                        throw new Exception("没有匹配的操纵符：" + op);
                    }
                }
                i++;
            }
        }
        return nodesStack.pop();
        
    }
    private double doOperate(double n0, double n1, char op) throws Exception{
        switch(op){
        case '+': return n0 + n1;
        case '-': return n0 - n1;
        case '*': return n0 * n1;
        case '/': return n0 / n1;
        default: throw new Exception("犯科操纵符：" + op);
        }
    }
    private int getSub(char c){
        switch(c){
            case '+': return 0;
            case '-': return 1;
            case '*': return 2;
            case '/': return 3;
            case '(': return 4;
            case ')': return 5;
            case '#': return 6;
            default : return -1;
        }
    }
}
class TreeNode{
    public double value;
    public char op = 'E';
    public TreeNode lft;
    public TreeNode rt;
    public TreeNode(double value){
        this.value = value;
    }
    public TreeNode(double value, char op, TreeNode lft, TreeNode rt){
        this.value = value;
        this.op = op;
        this.lft = lft;
        this.rt = rt;
    }
    StringBuilder buf = new StringBuilder();
    public String toString(){
        out(this);
        return buf.toString();
    }
    private void out(TreeNode node){
        if(node == null) return;
        out(node.lft);
        if(node.op != 'E')
            buf.append(node.op);
        else
            buf.append(node.value);
        out(node.rt);
    }
}