ityanger
ityanger

基于逆波兰表达式实现图形化混合计算器

文章目录

  • 前言
  • 表达式求值
    • 一、问题分解
    • 二、表达式合法性检查
      • 1.括号必须成对出现
      • 2.运算符出现位置
    • 三、表达式的转换
    • 四、计算结果
  • 图形化设计
    • 一、设置界面
    • 二、判断监听器
      • 监听器
    • 三、进行合理输入
  • 源码
    • Calculator
    • CalculatorFrame
  • END

前言

计算器在现实生活中是很普遍的一种工具，所以很多初学者基本上就会用计算器来作为自己的第一个Java项目，当然对于我来说也并不意外。本文采用逆波兰算法来实现计算器的功能，为有需要的小伙伴详细讲解原理和具体实现。完整代码可以查看GitHub仓库。

表达式求值

一、问题分解

我们把算术表达式输入给计算器程序并得到最终的计算结果，背后应存在三个过程:

  1. 表达式合法性检查
  2. 表达式的转换
  3. 计算结果

因此我们可以先建立Calculator类，并加入合法性检验Check，表达式解析(原表达式转换成逆波兰表达式)Conversion和计算结果的方法Calculated，添加成员变量expression以及构造方法Calculator，用来注入和存放代表算术表达式的字符串。

主要代码框架如下:

public class Calculator {
    //存放算术表达式
    private String expression;
    /**
     * 构造函数
     * @param expression 算术表达式
     */
    public Calculator(String expression) {
        this.expression = expression;
    }
    /**
     * @初始化
     */
    public void init() {
       
    }
    /**
     * @表达式合法性检验
     * @return 是否合法
     */
    public boolean Check() {
        return false or true;
    }
    /**
     * @转化为逆波兰式
     * @return 存储在Stack中的逆波兰表达式
     */
    public Stack<String> Conversion() {
        return stack;
    }
    /**
     * 计算结果
     * @return 表达式计算结果
     */
    public String Calculated() {
        return "0";
    }
}

下面我们逐步分析并实现这些过程。

二、表达式合法性检查

(1).合法性检查即对用户输入的表达式进行检验，判断其结构和语义是否存在不合法。例如我们期望的用户输入的合法表达式如下：

1+2
10*20-1 
-2*20+10/0.5 
(10+3)/(20-5)

(2).而不合法的表达式输入会是这样：

10*2/0
(10+30)/(20-5
2+3*
+6*3+5
2*-10-20

(3).诸如此类，我们可以从中总结一些有关表达式合法与否的规则:

  1. 括号必定成对出现.
  2. 除数不能为0(由于这个不好判断，故放在了计算的时候判断).
  3. 运算符不能出现在表达式开始或末尾，也不能出现在左括号的右侧或右括号的左侧.
  4. 运算符不能连续出现.

为了方便运算，我们将在负号前面加上0.

1.括号必须成对出现

我们先考虑括号必须成对出现的规则。这里我们可以使用多种方法来检验。

  1. 我们可以设置一个计数器且初值为0，在遍历数组时，每当读取到(，计数器加1；读取到)，计数器减1。任何时候计数器的值都不能小于0，且遍历结束后计数器的值必须也随即归0，否则代表括号未成对出现，即表达式不合法。
  2. 我们可以使用栈(Stack)来解决该问题。在遍历数组时，每当读取到(，将其压入栈；每当读到)，将栈中的(弹出栈。如果当读取到)时栈为空，或遍历结束后栈未空，代表括号未成对出现，即表达式不合法。

由于方法1比较简便，故下面采取方法1的实现:

/**
 * @表达式的合法性检测
 * @return boolean
 */
public boolean Check() {
    //首先在负号前面补0
    for (int i = 0; i < expression.length(); i++) {
        if (expression.charAt(i) == '-' && ((i > 0 && !Character.isDigit(expression.charAt(i - 1))) || i == 0)) {
            StringBuilder exp = new StringBuilder(expression);
            exp.insert(i, "0");
            expression = exp.toString();System.out.println(expression);
        }
    }
    //判断括号是否匹配，'('加1，')'减1
    int backets = 0;
    //从左向右扫描
    for (int i = 0; i < expression.length(); i++) {
        switch (expression.charAt(i)) {
            case '(': ++backets; break; //'('加1
            case ')': --backets; //')'减1
                if (backets < 0) //中间出现'('少于')'的情况
                    return false;
                break;
        }
    }
    if (backets != 0) //如果括号不匹配
        return false;
    return true;
}

代码比较清晰，完全按照方法1的思路实现，并且添加了详细注释，不继续赘述。

2.运算符出现位置

根据运算符不能出现在表达式开始或末尾，也不能出现在左括号的右侧或右括号的左侧，运算符不能连续出现，其中-是可以出现在首位的。这个我们可以利用下标，在循环遍历的switch分支中便捷地检验上述情况。

/**
 * @表达式的合法性检测
 * @return boolean
 */
public boolean Check() {
    //首先在负号前面补0
    for (int i = 0; i < expression.length(); i++) {
        if (expression.charAt(i) == '-' && ((i > 0 && !Character.isDigit(expression.charAt(i - 1))) || i == 0)) {
            StringBuilder exp = new StringBuilder(expression);
            exp.insert(i, "0");
            expression = exp.toString();System.out.println(expression);
        }
    }
    //判断括号是否匹配，'('加1，')'减1
    int backets = 0;
    //从左向右扫描
    for (int i = 0; i < expression.length(); i++) {
        switch (expression.charAt(i)) {
            case '(': ++backets; break; //'('加1
            case ')': --backets; //')'减1
                if (backets < 0) //中间出现'('少于')'的情况
                    return false;
                break;
            case '/':
            case '*':
            case '+':
                if (i == 0) return false; // '/'、'*'、'+'不能出现首位
                if (i > 0 && (expression.charAt(i - 1) == '/' || expression.charAt(i - 1) == '*' || expression.charAt(i - 1) == '+' || expression.charAt(i - 1) == '-' || expression.charAt(i - 1) == '('))
                    return false; //运算符不能连续出现且前面不能为'('
            case '-':
                if (i == expression.length() - 1) return false; //运算符不能出现在尾部
                if (expression.charAt(i + 1) == '/' || expression.charAt(i + 1) == '*' || expression.charAt(i + 1) == '+' || expression.charAt(i + 1) == '-' || expression.charAt(i + 1) == ')')
                    return false; //运算符不能连续出现且后面不能为')'
        }
    }
    if (backets != 0) //如果括号不匹配
        return false;
    return true;
}

至此，算术表达式合法性检验方法实现完毕。

三、表达式的转换

接下来我们来分析如何进行表达式的转换。我们都知道四则运算的法则，先乘除后加减，有括号先算括号里的，有多层括号先算内层括号里的。

但是，我们并不能轻而易举地处理一个字符串类型的算术表达式的运算优先级问题，即便是语言工具已经为我们提供了强大的计算能力。因为计算机并不能理解所谓四则运算优先级诸如此类的概念。此时，我们将引出一把宝刀——逆波兰表达式。
具体的内容可详看:波兰式与逆波兰式的转换和表达式求值.

那么知道了什么是逆波兰表达式，下面就进入正题。

1.先引入存放运算符优先级的Map类型成员变量，并完善构造方法：

private Map<String, Integer> priority = new HashMap<>();
/**
 * @构造方法
 * @param expression
 */
public Calculator(String expression) {
    init();
    this.expression = expression;
}
/**
 * @初始化
 */
public void init() {
    priority.put("/", 1);
    priority.put("*", 1);
    priority.put("-", 0);
    priority.put("+", 0);
    priority.put("(", -1);
    priority.put(")", -1);
    priority.put("#", -2);
}

由以上算法思想我们可以逐步实现Conversion方法来实现普通表达式到逆波兰表达式的转化:

/**
 * @中缀表达式转换为后缀表达式
 * @return Stack
 */
public Stack<String> Conversion() {
    Stack<String> s1 = new Stack<>();
    Stack<String> s2 = new Stack<>();
    s1.push("#"); //将最低优先级的#符号放入S1栈，为了方便统一后续操作
    for (int i = 0; i < expression.length(); i++) { //循环遍历表达式
        switch (expression.charAt(i)) {
            case '(': s1.push("("); break; //读取到左括号，直接压入S1栈
            case ')': //若取出的字符是")"，则将距离S1栈栈顶最近的"("之间的运算符，逐个出栈，依次送入S2栈，此时抛弃"("。
                while (!s1.peek().equals("(")) {
                    s2.push(s1.pop());
                }
                s1.pop(); break;
            case '/':
            case '*':
            case '-':
            case '+':
                /*
                * 若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，
                * 如果该运算符优先级(不包括括号运算符)大于S1栈栈顶运算符优先级，则将该运算符进S1栈，
                * 否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于(不包括等于)该运算符优先级，
                * 最后将该运算符送入S1栈。
                * */
                if (priority.get(expression.charAt(i) + "") > priority.get(s1.peek())) {
                    s1.push(expression.charAt(i) + "");
                }
                else {
                    while (!(priority.get(expression.charAt(i) + "") > priority.get(s1.peek()))) {
                        s2.push(s1.pop());
                    }
                    s1.push(expression.charAt(i) + "");
                }
                break;
            default:
                //若取出的字符是操作数，则分析出完整的运算数
                StringBuilder num = new StringBuilder();
                while (Character.isDigit(expression.charAt(i)) || expression.charAt(i) == '.') {
                    num.append(expression.charAt(i));
                    if (i + 1 < expression.length() && (Character.isDigit(expression.charAt(i + 1)) || expression.charAt(i + 1) == '.'))
                        ++i;
                    else break;
                }
                //该操作数直接送入S2栈
                s2.push(num.toString()); break;
        }
    }
    //将S1栈内所有运算符(不包括"#")，逐个出栈，依次送入S2栈。
    while (!s1.peek().equals("#"))
        s2.push(s1.pop());
    //由于栈的特性，S2应做一下逆序处理
    Stack<String> stack = new Stack<>();
    while (!s2.empty()) {
        stack.push(s2.pop());
    }
    return stack; //返回S2的逆序栈
}

四、计算结果

1.得到逆波兰表达式后，我们就要计算结果了。计算方法上文已经提到，这里方便大家再写一遍:

  • 扫描从左往右进行，如果扫描到操作数，则压进S，如果扫描到操作符，则从S弹出两个操作数进行相应的操作，并将结果压进S(S出2进1)，当扫描结束后，S的栈顶就是表达式结果。

2.按照上述算法实现Calculated比较简单，具体代码如下:

/**
 * @逆波兰式的求值
 * @return String
 */
public String Calculated() {
    if (!this.Check()) //合法性检验
        return "Error!"; //不合法返回"Error!"
    Stack<String> stack = Conversion(); //得到逆波兰表达式
    Stack<Double> tmp = new Stack<>(); //声明一个栈
    while (!stack.empty()) {
        String s = stack.pop(); //取出逆波兰中的值
        if (Character.isDigit(s.charAt(0))) //如果是操作数
            tmp.push(Double.parseDouble(s)); //直接进入tmp栈
        else {//如果是运算符，取出两个数进行计算
            double b = tmp.pop();
            double a = tmp.pop();
            switch (s) {
                case "/":
                    if (b == 0.0) //如果除数为0，报错
                        return "Error!";
                    tmp.push(Div(a, b)); break;
                case "*": tmp.push(Mul(a, b)); break;
                case "-": tmp.push(Sub(a, b)); break;
                case "+": tmp.push(Add(a, b)); break;
            }
        }
    }
    return tmp.pop().toString();
}
public double Div(double a, double b) {
    BigDecimal a1 = new BigDecimal(a);
    BigDecimal b1 = new BigDecimal(b);
    return a1.divide(b1, 5, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public double Mul(double a, double b) {
    return a * b;
}
public double Sub(double a, double b) {
    return a - b;
}
public double Add(double a, double b) {
    return a + b;
}

3.Calculator类的使用方法:

public static void main(String[] args) {
    System.out.print("输入算式：");
    Scanner scanner = new Scanner(System.in);
    String express = scanner.nextLine();
    Calculator calculator = new Calculator(express);
    System.out.println(calculator.Calculated());
}

4.输出结果:

输入算式：(1+2)*6+1
19.0

图形化设计

这个图形化设计我就不多说了，简要说一下就行了。

首先，我们设计一个图形界面肯定需要下面这几个步骤:

  1. 设置界面
  2. 判断监听器
  3. 进行合理输入

一、设置界面

大家根据自己的个人喜好，随意设计。我的大概界面如下图:

基于逆波兰表达式实现图形化混合计算器_第1张图片
程序中组件介绍:

  1. JLabel #标签
  2. JTextField #文本框
  3. JButton #按钮

界面大家就自己设置就行了，我就不再过多的赘余了，代码中有详细的注释，具体见代码:

public class CalculatorFrame extends JFrame {
    JLabel resultLabel = new JLabel(); //结果存放处
    JTextField inputText = new JTextField("0"); //输入框
    JButton clearEmpty = new JButton("CE"); //清除当前输入按钮
    JButton clear = new JButton("C"); //清除所有输入按钮
    JButton backSpace = new JButton("BackSpace"); //删除按钮
    JButton leftPer = new JButton("("); //左括号按钮
    JButton rightPer = new JButton(")"); //右括号按钮
    JButton divisor = new JButton("/"); //除号按钮
    JButton multiply = new JButton("*"); //乘号按钮
    JButton minus = new JButton("-"); //减号按钮
    JButton plus = new JButton("+"); //加号按钮
    JButton posNeg = new JButton("+/-"); //正负号按钮
    JButton decimalPoint = new JButton("."); //小数点按钮
    JButton radicalSign = new JButton("√"); //开根号按钮
    JButton equal = new JButton("="); //等于号按钮
    JButton[] button =  new JButton[10]; //0~9按钮
    public static void main(String[] args) {
        new CalculatorFrame();
    }
    CalculatorFrame() {
        init();
        setLayout(null);
        setTitle("计算器");
        setResizable(false);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setBounds(400, 100, 365, 420);
        setVisible(true);
    }
    public void init() {
        //字体
        Font font = new Font("Courier new", Font.PLAIN, 20);

        //最终结果标签
        resultLabel.setBounds(20, 20, 310, 25); //设置位置和宽高
        resultLabel.setFont(font); //添加字体样式
        add(resultLabel); //添加到窗体

        //输入框样式
        LineBorder lineBorder = new LineBorder(Color.lightGray, 3, true);
        inputText.setBorder(lineBorder); //添加样式
        inputText.setEditable(false); //文本框是否可编辑
        inputText.setBounds(20, 45, 310, 25); //设置位置和宽高
        inputText.setFont(font); //添加字体样式
        add(inputText); //添加到窗体

        //CE按钮样式
        clearEmpty.setBounds(20, 90, 70, 35);
        clearEmpty.setFont(font);
        add(clearEmpty);

        //C按钮样式
        clear.setBounds(100, 90, 70, 35);
        clear.setFont(font);
        add(clear);

        //BackSpace按钮样式
        backSpace.setBounds(180, 90, 150, 35);
        backSpace.setFont(font);
        add(backSpace);

        //除号按钮样式
        divisor.setBounds(260, 135, 70, 35);
        divisor.setFont(font);
        add(divisor);

        //乘号按钮样式
        multiply.setBounds(260, 180, 70, 35);
        multiply.setFont(font);
        add(multiply);

        //减号按钮样式
        minus.setBounds(260, 225, 70, 35);
        minus.setFont(font);
        add(minus);

        //加号按钮样式
        plus.setBounds(260, 270, 70, 35);
        plus.setFont(font);
        add(plus);
        int i = 1;

        //0号按钮样式
        button[0] = new JButton("0");
        button[0].setBounds(20, 270, 70, 35);
        button[0].setFont(font);
        add(button[0]);

        //正负号按钮样式
        posNeg.setBounds(100, 270, 70, 35);
        posNeg.setFont(font);
        add(posNeg);

        //小数点按钮样式
        decimalPoint.setBounds(180, 270, 70, 35);
        decimalPoint.setFont(font);
        add(decimalPoint);

        //1~9按钮样式
        for (int j = 225; j >= 135; j -= 45) {
            for (int k = 20; k <= 180; k += 80) {
                button[i] = new JButton(Integer.toString(i));
                button[i].setBounds(k, j, 70, 35);
                button[i].setFont(font);
                add(button[i++]);
            }
        }

        //左括号按钮样式
        leftPer.setBounds(20, 315, 70, 35);
        leftPer.setFont(font);
        add(leftPer);

        //右括号按钮样式
        rightPer.setBounds(100, 315, 70, 35);
        rightPer.setFont(font);
        add(rightPer);

        //根号按钮样式
        radicalSign.setBounds(180, 315, 70, 35);
        radicalSign.setFont(font);
        add(radicalSign);

        //等于号按钮样式
        equal.setBounds(260, 315, 70, 35);
        equal.setFont(font);
        add(equal);
    }
}

二、判断监听器

监听器

当用户按下一个按钮或者单击某个菜单项时，这些动作就会激发一个相应的事件，该事件就会触发事件源上注册的事件监听器(特殊的Java对象)，事件监听器调用相应的事件处理器(事件监听器里的实例方法)来做出相应的响应。

三种方法:

  1. 匿名内部类;
  2. 匿名外部类;
  3. 实现接口;

这里使用第三种方法——自身类实现ActionListener接口，作为事件监听器:

public class CalculatorFrame extends JFrame implements ActionListener {
    JLabel resultLabel = new JLabel(); //结果存放处
    JTextField inputText = new JTextField("0"); //输入框
    JButton clearEmpty = new JButton("CE"); //清除当前输入按钮
    JButton clear = new JButton("C"); //清除所有输入按钮
    JButton backSpace = new JButton("BackSpace"); //删除按钮
    JButton leftPer = new JButton("("); //左括号按钮
    JButton rightPer = new JButton(")"); //右括号按钮
    JButton divisor = new JButton("/"); //除号按钮
    JButton multiply = new JButton("*"); //乘号按钮
    JButton minus = new JButton("-"); //减号按钮
    JButton plus = new JButton("+"); //加号按钮
    JButton posNeg = new JButton("+/-"); //正负号按钮
    JButton decimalPoint = new JButton("."); //小数点按钮
    JButton radicalSign = new JButton("√"); //开根号按钮
    JButton equal = new JButton("="); //等于号按钮
    JButton[] button =  new JButton[10]; //0~9按钮
    StringBuffer s1 = new StringBuffer("0"); //记录运算数字，以及保留结果
    StringBuffer s2 = new StringBuffer(); //记录运算数字，保留上一个输入的数字或运算结果
    boolean operator = false; //判断上次输入的是否为运算符
    boolean start = true; //标记运算开始或结束,保证一次运算之后，第二次进行运算时能同时清空显示界面，即s1为空
    public static void main(String[] args) {
        new CalculatorFrame();
    }
    CalculatorFrame() {
        init();
        setLayout(null);
        setTitle("计算器");
        setResizable(false);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setBounds(400, 100, 365, 420);
        setVisible(true);
    }
    public void init() {
        //字体
        Font font = new Font("Courier new", Font.PLAIN, 20);

        //最终结果标签
        resultLabel.setBounds(20, 20, 310, 25); //设置位置和宽高
        resultLabel.setFont(font); //添加字体样式
        add(resultLabel); //添加到窗体

        //输入框样式
        LineBorder lineBorder = new LineBorder(Color.lightGray, 3, true);
        inputText.setBorder(lineBorder); //添加样式
        inputText.setEditable(false); //文本框是否可编辑
        inputText.setBounds(20, 45, 310, 25); //设置位置和宽高
        inputText.setFont(font); //添加字体样式
        add(inputText); //添加到窗体

        //CE按钮样式
        clearEmpty.setBounds(20, 90, 70, 35);
        clearEmpty.setFont(font);
        add(clearEmpty);
        clearEmpty.addActionListener(this); //设置监听器

        //C按钮样式
        clear.setBounds(100, 90, 70, 35);
        clear.setFont(font);
        add(clear);
        clear.addActionListener(this);

        //BackSpace按钮样式
        backSpace.setBounds(180, 90, 150, 35);
        backSpace.setFont(font);
        add(backSpace);
        backSpace.addActionListener(this);

        //除号按钮样式
        divisor.setBounds(260, 135, 70, 35);
        divisor.setFont(font);
        add(divisor);
        divisor.addActionListener(this);

        //乘号按钮样式
        multiply.setBounds(260, 180, 70, 35);
        multiply.setFont(font);
        add(multiply);
        multiply.addActionListener(this);

        //减号按钮样式
        minus.setBounds(260, 225, 70, 35);
        minus.setFont(font);
        add(minus);
        minus.addActionListener(this);

        //加号按钮样式
        plus.setBounds(260, 270, 70, 35);
        plus.setFont(font);
        add(plus);
        plus.addActionListener(this);
        int i = 1;

        //0号按钮样式
        button[0] = new JButton("0");
        button[0].setBounds(20, 270, 70, 35);
        button[0].setFont(font);
        add(button[0]);
        button[0].addActionListener(this);

        //正负号按钮样式
        posNeg.setBounds(100, 270, 70, 35);
        posNeg.setFont(font);
        add(posNeg);
        posNeg.addActionListener(this);

        //小数点按钮样式
        decimalPoint.setBounds(180, 270, 70, 35);
        decimalPoint.setFont(font);
        add(decimalPoint);
        decimalPoint.addActionListener(this);

        //1~9按钮样式
        for (int j = 225; j >= 135; j -= 45) {
            for (int k = 20; k <= 180; k += 80) {
                button[i] = new JButton(Integer.toString(i));
                button[i].setBounds(k, j, 70, 35);
                button[i].setFont(font);
                button[i].addActionListener(this);
                add(button[i++]);
            }
        }

        //左括号按钮样式
        leftPer.setBounds(20, 315, 70, 35);
        leftPer.setFont(font);
        add(leftPer);
        leftPer.addActionListener(this);

        //右括号按钮样式
        rightPer.setBounds(100, 315, 70, 35);
        rightPer.setFont(font);
        add(rightPer);
        rightPer.addActionListener(this);

        //根号按钮样式
        radicalSign.setBounds(180, 315, 70, 35);
        radicalSign.setFont(font);
        add(radicalSign);
        radicalSign.addActionListener(this);

        //等于号按钮样式
        equal.setBounds(260, 315, 70, 35);
        equal.setFont(font);
        add(equal);
        equal.addActionListener(this);
    }
    //监听器
    public void actionPerformed(ActionEvent e) {
        //判断是否为按钮0
        if (e.getSource().equals(button[0])) {
            
        }

        //判断是否为1~9按钮
        for (int i = 1; i <= 9; i++) {
            if (e.getSource().equals(button[i])) {
                
            }
        }

        //判断小数点
        if (e.getSource().equals(decimalPoint)) {
            
        }

        //判断正负号
        if (e.getSource().equals(posNeg)) {
            
        }

        //判断退格Backspace
        if (e.getSource().equals(backSpace)) {
            
        }

        //判断归零CE
        if (e.getSource().equals(clearEmpty)) {
            
        }

        //判断清除C
        if (e.getSource().equals(clear)) {
            
        }

        //判断加号
        if (e.getSource().equals(plus)) {
            
        }

        //判断减号
        if (e.getSource().equals(minus)) {
            
        }

        //判断乘号
        if (e.getSource().equals(multiply)) {
            
        }

        //判断除号
        if (e.getSource().equals(divisor)) {
            
        }

        //判断左括号
        if (e.getSource().equals(leftPer)) {
            
        }

        //判断右括号
        if (e.getSource().equals(rightPer)) {
            
        }

        //判断根号
        if (e.getSource().equals(radicalSign)) {
            
        }
        //判断等号
        if (e.getSource().equals(equal)) {
            
        }
    }
}

三、进行合理输入

(1).我们知道， 我们的算术表达式是不能随意输入的，要符合我们正常的算术表达式的逻辑形式。我们知道合法输入应具备下面这些条件:

  1. 数字没有前导0
  2. 小数点只能跟在数字后面且只能出现一次
  3. 左括号前面必须是运算符、左括号或者空
  4. 左括号后面不能直接跟运算符
  5. 右括号前面必须是数字或右括号
  6. 右括号后面不能直接跟数字
  7. 根号下面的结果必须是数字且大于等于0

我们知道，我们计算算术表达式的程序返回的结果有可能是Error!此时运算符、小数点、左右括号、等于号是不能用的。最后，我们可以得到:

public void actionPerformed(ActionEvent e) {
    //判断是否为按钮0
    if (e.getSource().equals(button[0])) {
        if (!s1.toString().equals("0") && !s1.toString().equals("-0") && s1.charAt(s1.length() - 1) != ')') { //')'后面不能直接跟数字
            if (!start || s1.charAt(0) == 'E') { //如果是开始新一轮的运算或是有错误提示
                //s1清零，保证可以重新输入数字
                s1.delete(0, s1.length());
                s2.delete(0, s2.length());
            }
            start = true;
            s1.append("0");
            operator = false;
        }
    }

    //判断是否为1~9按钮
    for (int i = 1; i <= 9; i++) {
        if (e.getSource().equals(button[i])) {
            if (!start || s1.charAt(0) == 'E') { //如果是开始新一轮的运算或是有错误提示
                s1.delete(0, s1.length()); //清空
                s2.delete(0, s2.length());
            }
            start = true;
            if (s1.toString().equals("0") || s1.toString().equals("-0"))
                s1.deleteCharAt(s1.length() - 1); //去除开始的0
            if (s1.length() == 0 || s1.charAt(s1.length() - 1) != ')')
                s1.append(i); //')'后面不能直接跟数字
            operator = false; //输入的不是运算符
        }
    }

    //判断小数点
    if (e.getSource().equals(decimalPoint)) {
        if (!start || s1.charAt(0) == 'E') {
            s1.delete(0, s1.length());
            s1.append("0");
            s2.delete(0, s2.length());
        }
        start = true;
        if (Character.isDigit(s1.charAt(s1.length() - 1)) && s1.indexOf(".") == -1)
            s1.append("."); //如果前面是数字且没出现过小数点
        operator = false; //输入的不是运算符
    }

    //判断正负号
    if (e.getSource().equals(posNeg)) {
        if (s1.charAt(0) == 'E') //如果是错误提示
            return ;
        if (!start) { //如果开始新的运算
            s1.delete(0, s1.length());
            s1.append("0");
            s2.delete(0, s2.length());
        }
        start = true;
        int i;
        for (i = s1.length() - 1; i > 0; --i) //从前往后找，直到遇到不是数字或小数点，在其添加负号
            if (!Character.isDigit(s1.charAt(i)) && s1.charAt(i) != '.')
                break;
        if (Character.isDigit(s1.charAt(i))) //如果都是数字
            s1.insert(i, '-');
        else  if (s1.charAt(i) != '-') //如果此处不是负号，添加负号
            s1.insert(i + 1, '-');
        else s1.deleteCharAt(i); //否则已经有负号，删除
        operator = false; //输入的不是运算符
    }

    //判断退格Backspace
    if (e.getSource().equals(backSpace)) {
        start = true;
        s1.deleteCharAt(s1.length() - 1); //删除最后一个
        if (s1.length() == 0)
            s1.append("0");
        operator = false;
    }

    //判断归零CE
    if (e.getSource().equals(clearEmpty)) {
        //清空当前输入，即s1清零
        //start = true;
        s1.delete(0, s1.length()); //清空
        s1.append("0");
        operator = false;
    }

    //判断清除C
    if (e.getSource().equals(clear)) {
        //清空所有，start标记设为true
        start = true;
        s1.delete(0, s1.length());
        s2.delete(0, s2.length());
        s1.append("0");
        operator = false;
    }

    //判断加号
    if (e.getSource().equals(plus)) {
        if (s1.charAt(0) == 'E') //如果是错误提示，无操作
            return ;
        if (!start)
            s2.delete(0, s2.length());
        //运算符前面不能是做括号和小数点，自动舍去
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        //如果上次是运算符，那么就可以替换上次输入的运算符
        if (operator && s2.length() > 0) {
            s2.deleteCharAt(s2.length() - 1);
            s2.append("+");
        }
        else if (s1.length() > 0) //如果s1还有数据
            s2.append(s1.toString() + "+");
        //s1清零，重新接收下一个数据
        s1.delete(0, s1.length());
        s1.append("0");
        start = true;
        operator = true;
    }

    //判断减号
    if (e.getSource().equals(minus)) {
        if (s1.charAt(0) == 'E')
            return ;
        if (!start)
            s2.delete(0, s2.length());
        //运算符前面不能是做括号和小数点，自动舍去
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        //如果上次是运算符，那么就可以替换上次输入的运算符
        if (operator && s2.length() > 0) {
            s2.deleteCharAt(s2.length() - 1);
            s2.append("-");
        }
        else if (s1.length() > 0) //如果s1还有数据
            s2.append(s1.toString() + "-");
        s1.delete(0, s1.length());
        s1.append("0");
        start = true;
        operator = true;
    }

    //判断乘号
    if (e.getSource().equals(multiply)) {
        if (s1.charAt(0) == 'E')
            return ;
        if (!start)
            s2.delete(0, s2.length());
        //运算符前面不能是做括号和小数点，自动舍去
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        //如果上次是运算符，那么就可以替换上次输入的运算符
        if (operator && s2.length() > 0) {
            s2.deleteCharAt(s2.length() - 1);
            s2.append("*");
        }
        else if (s1.length() > 0) //如果s1还有数据
            s2.append(s1.toString() + "*");
        s1.delete(0, s1.length());
        s1.append("0");
        start = true;
        operator = true;
    }

    //判断除号
    if (e.getSource().equals(divisor)) {
        if (s1.charAt(0) == 'E')
            return ;
        if (!start)
            s2.delete(0, s2.length());
        //运算符前面不能是做括号和小数点，自动舍去
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        //如果上次是运算符，那么就可以替换上次输入的运算符
        if (operator && s2.length() > 0) {
            s2.deleteCharAt(s2.length() - 1);
            s2.append("/");
        }
        else if (s1.length() > 0) //如果s1还有数据
            s2.append(s1.toString() + "/");

        s1.delete(0, s1.length());
        s1.append("0");
        start = true;
        operator = true;
    }

    //判断左括号
    if (e.getSource().equals(leftPer)) {
        if (!start || s1.charAt(0) == 'E') { //开始新一轮的运算或是错误信息
            s1.delete(0, s1.length()); //清空
            s1.append("0");
            s2.delete(0, s2.length());
        }
        start = true;
        //只能在初始状态的时候或者左边为左括号的时候才能添加左括号
        if (s1.toString().equals("0") || s1.toString().equals("-0")) { //如果是初始状态
            s1.deleteCharAt(s1.length() - 1);
            s1.append("(");
        }
        else if (s1.charAt(s1.length() - 1) == '(') //
            s1.append("(");
        operator = false;
    }

    //判断右括号
    if (e.getSource().equals(rightPer)) {
        if (!start || s1.charAt(0) == 'E') {
            s1.delete(0, s1.length());
            s1.append("0");
            s2.delete(0, s2.length());
        }
        start = true;
        //前面必须是数字或右括号才能添加
        if (Character.isDigit(s1.charAt(s1.length() - 1)) || s1.charAt(s1.length() - 1) == ')')
            s1.append(")");
        operator = false;
    }

    //判断根号
    if (e.getSource().equals(radicalSign)) {
        if (s1.charAt(0) == 'E')
            return ;
        start = false;
        //删除无用的数据
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        if (s1.length() == 0)
            s1.append("0");
        String str = new Calculator(s1.toString()).Calculated();//先计算出s1中的表达式
        s2.delete(0, s2.length());
        s2.append(s1);
        s1.delete(0, s1.length());
        s2.insert(0, "√(");
        if (str.equals("Error!") || Double.parseDouble(str) < 0) //如果表达式有错误或结果为负数
            s1.append("Error!");
        else {
            double s = Double.parseDouble(str);
            s1.append(Math.sqrt(s));
        }
        s2.append(")");
        operator = false;
    }

    //判断等号
    if (e.getSource().equals(equal)) {
        if (s1.charAt(0) == 'E')
            return ;
        start = false;
        //删除无用的数据
        while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
            s1.deleteCharAt(s1.length() - 1);
        }
        //如果s1为空，补0
        if (s1.length() == 0)
            s1.append("0");
        String str = new Calculator(s2.append(s1.toString()).toString()).Calculated(); //计算
        if (!str.equals("Error!")) //不是错误信息
            s2.append( "=" + str);
        else s2.append("=");
        s1.delete(0, s1.length());
        s1.append(str);
        operator = false;
    }
    inputText.setText(s1.toString()); //添加到输入框
    resultLabel.setText(s2.toString()); //添加到结果标签
}

上面的程序实现了表达式的判定和计算，为了让计算器有更好的体验，我们可以为计算器加上图形界面，下面的代码主要就是实现了一个图形界面，配合上面的代码，就可以组成一个完美的计算器:

源码

Calculator

这个是计算表达式的源码，可直接运行。

package Calculator;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;

public class Calculator {
    private String expression; //存储表达式
    private Map<String, Integer> priority = new HashMap<>();
    /**
     * @构造方法
     * @param expression
     */
    public Calculator(String expression) {
        init();
        this.expression = expression;
    }
    /**
     * @初始化
     */
    public void init() {
        priority.put("/", 1);
        priority.put("*", 1);
        priority.put("-", 0);
        priority.put("+", 0);
        priority.put("(", -1);
        priority.put(")", -1);
        priority.put("#", -2);
    }
    /**
     * @表达式的合法性检测
     * @return boolean
     */
    public boolean Check() {
        //首先在负号前面补0
        for (int i = 0; i < expression.length(); i++) {
            if (expression.charAt(i) == '-' && ((i > 0 && !Character.isDigit(expression.charAt(i - 1))) || i == 0)) {
                StringBuilder exp = new StringBuilder(expression);
                exp.insert(i, "0");
                expression = exp.toString();System.out.println(expression);
            }
        }
        //判断括号是否匹配，'('加1，')'减1
        int backets = 0;
        //从左向右扫描
        for (int i = 0; i < expression.length(); i++) {
            switch (expression.charAt(i)) {
                case '(': ++backets; break; //'('加1
                case ')': --backets; //')'减1
                    if (backets < 0) //中间出现'('少于')'的情况
                        return false;
                    break;
                case '/':
                case '*':
                case '+':
                    if (i == 0) return false; // '/'、'*'、'+'不能出现首位
                    if (i > 0 && (expression.charAt(i - 1) == '/' || expression.charAt(i - 1) == '*' || expression.charAt(i - 1) == '+' || expression.charAt(i - 1) == '-' || expression.charAt(i - 1) == '('))
                        return false; //运算符不能连续出现且前面不能为'('
                case '-':
                    if (i == expression.length() - 1) return false; //运算符不能出现在尾部
                    if (expression.charAt(i + 1) == '/' || expression.charAt(i + 1) == '*' || expression.charAt(i + 1) == '+' || expression.charAt(i + 1) == '-' || expression.charAt(i + 1) == ')')
                        return false; //运算符不能连续出现且后面不能为')'
            }
        }
        if (backets != 0) //如果括号不匹配
            return false;
        return true;
    }

    /**
     * @中缀表达式转换为后缀表达式
     * @return Stack
     */
    public Stack<String> Conversion() {
        Stack<String> s1 = new Stack<>();
        Stack<String> s2 = new Stack<>();
        s1.push("#"); //将最低优先级的#符号放入S1栈，为了方便统一后续操作
        for (int i = 0; i < expression.length(); i++) { //循环遍历表达式
            switch (expression.charAt(i)) {
                case '(': s1.push("("); break; //读取到左括号，直接压入S1栈
                case ')': //若取出的字符是")"，则将距离S1栈栈顶最近的"("之间的运算符，逐个出栈，依次送入S2栈，此时抛弃"("。
                    while (!s1.peek().equals("(")) {
                        s2.push(s1.pop());
                    }
                    s1.pop(); break;
                case '/':
                case '*':
                case '-':
                case '+':
                    /*
                    * 若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，
                    * 如果该运算符优先级(不包括括号运算符)大于S1栈栈顶运算符优先级，则将该运算符进S1栈，
                    * 否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于(不包括等于)该运算符优先级，
                    * 最后将该运算符送入S1栈。
                    * */
                    if (priority.get(expression.charAt(i) + "") > priority.get(s1.peek())) {
                        s1.push(expression.charAt(i) + "");
                    }
                    else {
                        while (!(priority.get(expression.charAt(i) + "") > priority.get(s1.peek()))) {
                            s2.push(s1.pop());
                        }
                        s1.push(expression.charAt(i) + "");
                    }
                    break;
                default:
                    //若取出的字符是操作数，则分析出完整的运算数
                    StringBuilder num = new StringBuilder();
                    while (Character.isDigit(expression.charAt(i)) || expression.charAt(i) == '.') {
                        num.append(expression.charAt(i));
                        if (i + 1 < expression.length() && (Character.isDigit(expression.charAt(i + 1)) || expression.charAt(i + 1) == '.'))
                            ++i;
                        else break;
                    }
                    //该操作数直接送入S2栈
                    s2.push(num.toString()); break;
            }
        }
        //将S1栈内所有运算符(不包括"#")，逐个出栈，依次送入S2栈。
        while (!s1.peek().equals("#"))
            s2.push(s1.pop());
        //由于栈的特性，S2应做一下逆序处理
        Stack<String> stack = new Stack<>();
        while (!s2.empty()) {
            stack.push(s2.pop());
        }
        return stack; //返回S2的逆序栈
    }

    /**
     * @逆波兰式的求值
     * @return String
     */
    public String Calculated() {
        if (!this.Check()) //合法性检验
            return "Error!"; //不合法返回"Error!"
        Stack<String> stack = Conversion(); //得到逆波兰表达式
        Stack<Double> tmp = new Stack<>(); //声明一个栈
        while (!stack.empty()) {
            String s = stack.pop(); //取出逆波兰中的值
            if (Character.isDigit(s.charAt(0))) //如果是操作数
                tmp.push(Double.parseDouble(s)); //直接进入tmp栈
            else {//如果是运算符，取出两个数进行计算
                double b = tmp.pop();
                double a = tmp.pop();
                switch (s) {
                    case "/":
                        if (b == 0.0) //如果除数为0，报错
                            return "Error!";
                        tmp.push(Div(a, b)); break;
                    case "*": tmp.push(Mul(a, b)); break;
                    case "-": tmp.push(Sub(a, b)); break;
                    case "+": tmp.push(Add(a, b)); break;
                }
            }
        }
        return tmp.pop().toString();
    }
    public double Div(double a, double b) {
        BigDecimal a1 = new BigDecimal(a);
        BigDecimal b1 = new BigDecimal(b);
        return a1.divide(b1, 5, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    public double Mul(double a, double b) {
        return a * b;
    }
    public double Sub(double a, double b) {
        return a - b;
    }
    public double Add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.print("输入算式：");
        Scanner scanner = new Scanner(System.in);
        String express = scanner.nextLine();
        Calculator calculator = new Calculator(express);
        System.out.println(calculator.Calculated());
    }
}

CalculatorFrame

这个是图形界面源码，里面需要用到Calculator类。

package Calculator;

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

public class CalculatorFrame extends JFrame implements ActionListener {
    JLabel resultLabel = new JLabel(); //结果存放处
    JTextField inputText = new JTextField("0"); //输入框
    JButton clearEmpty = new JButton("CE"); //清除当前输入按钮
    JButton clear = new JButton("C"); //清除所有输入按钮
    JButton backSpace = new JButton("BackSpace"); //删除按钮
    JButton leftPer = new JButton("("); //左括号按钮
    JButton rightPer = new JButton(")"); //右括号按钮
    JButton divisor = new JButton("/"); //除号按钮
    JButton multiply = new JButton("*"); //乘号按钮
    JButton minus = new JButton("-"); //减号按钮
    JButton plus = new JButton("+"); //加号按钮
    JButton posNeg = new JButton("+/-"); //正负号按钮
    JButton decimalPoint = new JButton("."); //小数点按钮
    JButton radicalSign = new JButton("√"); //开根号按钮
    JButton equal = new JButton("="); //等于号按钮
    JButton[] button =  new JButton[10]; //0~9按钮
    StringBuffer s1 = new StringBuffer("0"); //记录运算数字，以及保留结果
    StringBuffer s2 = new StringBuffer(); //记录运算数字，保留上一个输入的数字或运算结果
    boolean operator = false; //判断上次输入的是否为运算符
    boolean start = true; //标记运算开始或结束,保证一次运算之后，第二次进行运算时能同时清空显示界面，即s1为空
    public static void main(String[] args) {
        new CalculatorFrame();
    }
    CalculatorFrame() {
        init();
        setLayout(null);
        setTitle("计算器");
        setResizable(false);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setBounds(400, 100, 365, 420);
        setVisible(true);
    }
    public void init() {
        //字体
        Font font = new Font("Courier new", Font.PLAIN, 20);

        //最终结果标签
        resultLabel.setBounds(20, 20, 310, 25); //设置位置和宽高
        resultLabel.setFont(font); //添加字体样式
        add(resultLabel); //添加到窗体

        //输入框样式
        LineBorder lineBorder = new LineBorder(Color.lightGray, 3, true);
        inputText.setBorder(lineBorder); //添加样式
        inputText.setEditable(false); //文本框是否可编辑
        inputText.setBounds(20, 45, 310, 25); //设置位置和宽高
        inputText.setFont(font); //添加字体样式
        add(inputText); //添加到窗体

        //CE按钮样式
        clearEmpty.setBounds(20, 90, 70, 35);
        clearEmpty.setFont(font);
        add(clearEmpty);
        clearEmpty.addActionListener(this); //设置监听器

        //C按钮样式
        clear.setBounds(100, 90, 70, 35);
        clear.setFont(font);
        add(clear);
        clear.addActionListener(this);

        //BackSpace按钮样式
        backSpace.setBounds(180, 90, 150, 35);
        backSpace.setFont(font);
        add(backSpace);
        backSpace.addActionListener(this);

        //除号按钮样式
        divisor.setBounds(260, 135, 70, 35);
        divisor.setFont(font);
        add(divisor);
        divisor.addActionListener(this);

        //乘号按钮样式
        multiply.setBounds(260, 180, 70, 35);
        multiply.setFont(font);
        add(multiply);
        multiply.addActionListener(this);

        //减号按钮样式
        minus.setBounds(260, 225, 70, 35);
        minus.setFont(font);
        add(minus);
        minus.addActionListener(this);

        //加号按钮样式
        plus.setBounds(260, 270, 70, 35);
        plus.setFont(font);
        add(plus);
        plus.addActionListener(this);
        int i = 1;

        //0号按钮样式
        button[0] = new JButton("0");
        button[0].setBounds(20, 270, 70, 35);
        button[0].setFont(font);
        add(button[0]);
        button[0].addActionListener(this);

        //正负号按钮样式
        posNeg.setBounds(100, 270, 70, 35);
        posNeg.setFont(font);
        add(posNeg);
        posNeg.addActionListener(this);

        //小数点按钮样式
        decimalPoint.setBounds(180, 270, 70, 35);
        decimalPoint.setFont(font);
        add(decimalPoint);
        decimalPoint.addActionListener(this);

        //1~9按钮样式
        for (int j = 225; j >= 135; j -= 45) {
            for (int k = 20; k <= 180; k += 80) {
                button[i] = new JButton(Integer.toString(i));
                button[i].setBounds(k, j, 70, 35);
                button[i].setFont(font);
                button[i].addActionListener(this);
                add(button[i++]);
            }
        }

        //左括号按钮样式
        leftPer.setBounds(20, 315, 70, 35);
        leftPer.setFont(font);
        add(leftPer);
        leftPer.addActionListener(this);

        //右括号按钮样式
        rightPer.setBounds(100, 315, 70, 35);
        rightPer.setFont(font);
        add(rightPer);
        rightPer.addActionListener(this);

        //根号按钮样式
        radicalSign.setBounds(180, 315, 70, 35);
        radicalSign.setFont(font);
        add(radicalSign);
        radicalSign.addActionListener(this);

        //等于号按钮样式
        equal.setBounds(260, 315, 70, 35);
        equal.setFont(font);
        add(equal);
        equal.addActionListener(this);
    }
    //监听器
    public void actionPerformed(ActionEvent e) {
        //判断是否为按钮0
        if (e.getSource().equals(button[0])) {
            if (!s1.toString().equals("0") && !s1.toString().equals("-0") && s1.charAt(s1.length() - 1) != ')') { //')'后面不能直接跟数字
                if (!start || s1.charAt(0) == 'E') { //如果是开始新一轮的运算或是有错误提示
                    //s1清零，保证可以重新输入数字
                    s1.delete(0, s1.length());
                    s2.delete(0, s2.length());
                }
                start = true;
                s1.append("0");
                operator = false;
            }
        }

        //判断是否为1~9按钮
        for (int i = 1; i <= 9; i++) {
            if (e.getSource().equals(button[i])) {
                if (!start || s1.charAt(0) == 'E') { //如果是开始新一轮的运算或是有错误提示
                    s1.delete(0, s1.length()); //清空
                    s2.delete(0, s2.length());
                }
                start = true;
                if (s1.toString().equals("0") || s1.toString().equals("-0"))
                    s1.deleteCharAt(s1.length() - 1); //去除开始的0
                if (s1.length() == 0 || s1.charAt(s1.length() - 1) != ')')
                    s1.append(i); //')'后面不能直接跟数字
                operator = false; //输入的不是运算符
            }
        }

        //判断小数点
        if (e.getSource().equals(decimalPoint)) {
            if (!start || s1.charAt(0) == 'E') {
                s1.delete(0, s1.length());
                s1.append("0");
                s2.delete(0, s2.length());
            }
            start = true;
            if (Character.isDigit(s1.charAt(s1.length() - 1)) && s1.indexOf(".") == -1)
                s1.append("."); //如果前面是数字且没出现过小数点
            operator = false; //输入的不是运算符
        }

        //判断正负号
        if (e.getSource().equals(posNeg)) {
            if (s1.charAt(0) == 'E') //如果是错误提示
                return ;
            if (!start) { //如果开始新的运算
                s1.delete(0, s1.length());
                s1.append("0");
                s2.delete(0, s2.length());
            }
            start = true;
            int i;
            for (i = s1.length() - 1; i > 0; --i) //从前往后找，直到遇到不是数字或小数点，在其添加负号
                if (!Character.isDigit(s1.charAt(i)) && s1.charAt(i) != '.')
                    break;
            if (Character.isDigit(s1.charAt(i))) //如果都是数字
                s1.insert(i, '-');
            else  if (s1.charAt(i) != '-') //如果此处不是负号，添加负号
                s1.insert(i + 1, '-');
            else s1.deleteCharAt(i); //否则已经有负号，删除
            operator = false; //输入的不是运算符
        }

        //判断退格Backspace
        if (e.getSource().equals(backSpace)) {
            //start = true;
            s1.deleteCharAt(s1.length() - 1); //删除最后一个
            if (s1.length() == 0)
                s1.append("0");
            operator = false;
        }

        //判断归零CE
        if (e.getSource().equals(clearEmpty)) {
            //清空当前输入，即s1清零
            //start = true;
            s1.delete(0, s1.length()); //清空
            s1.append("0");
            operator = false;
        }

        //判断清除C
        if (e.getSource().equals(clear)) {
            //清空所有，start标记设为true
            start = true;
            s1.delete(0, s1.length());
            s2.delete(0, s2.length());
            s1.append("0");
            operator = false;
        }

        //判断加号
        if (e.getSource().equals(plus)) {
            if (s1.charAt(0) == 'E') //如果是错误提示，无操作
                return ;
            if (!start)
                s2.delete(0, s2.length());
            //运算符前面不能是做括号和小数点，自动舍去
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            //如果上次是运算符，那么就可以替换上次输入的运算符
            if (operator && s2.length() > 0) {
                s2.deleteCharAt(s2.length() - 1);
                s2.append("+");
            }
            else if (s1.length() > 0) //如果s1还有数据
                s2.append(s1.toString() + "+");
            //s1清零，重新接收下一个数据
            s1.delete(0, s1.length());
            s1.append("0");
            start = true;
            operator = true;
        }

        //判断减号
        if (e.getSource().equals(minus)) {
            if (s1.charAt(0) == 'E')
                return ;
            if (!start)
                s2.delete(0, s2.length());
            //运算符前面不能是做括号和小数点，自动舍去
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            //如果上次是运算符，那么就可以替换上次输入的运算符
            if (operator && s2.length() > 0) {
                s2.deleteCharAt(s2.length() - 1);
                s2.append("-");
            }
            else if (s1.length() > 0) //如果s1还有数据
                s2.append(s1.toString() + "-");
            s1.delete(0, s1.length());
            s1.append("0");
            start = true;
            operator = true;
        }

        //判断乘号
        if (e.getSource().equals(multiply)) {
            if (s1.charAt(0) == 'E')
                return ;
            if (!start)
                s2.delete(0, s2.length());
            //运算符前面不能是做括号和小数点，自动舍去
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            //如果上次是运算符，那么就可以替换上次输入的运算符
            if (operator && s2.length() > 0) {
                s2.deleteCharAt(s2.length() - 1);
                s2.append("*");
            }
            else if (s1.length() > 0) //如果s1还有数据
                s2.append(s1.toString() + "*");
            s1.delete(0, s1.length());
            s1.append("0");
            start = true;
            operator = true;
        }

        //判断除号
        if (e.getSource().equals(divisor)) {
            if (s1.charAt(0) == 'E')
                return ;
            if (!start)
                s2.delete(0, s2.length());
            //运算符前面不能是做括号和小数点，自动舍去
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            //如果上次是运算符，那么就可以替换上次输入的运算符
            if (operator && s2.length() > 0) {
                s2.deleteCharAt(s2.length() - 1);
                s2.append("/");
            }
            else if (s1.length() > 0) //如果s1还有数据
                s2.append(s1.toString() + "/");

            s1.delete(0, s1.length());
            s1.append("0");
            start = true;
            operator = true;
        }

        //判断左括号
        if (e.getSource().equals(leftPer)) {
            if (!start || s1.charAt(0) == 'E') { //开始新一轮的运算或是错误信息
                s1.delete(0, s1.length()); //清空
                s1.append("0");
                s2.delete(0, s2.length());
            }
            start = true;
            //只能在初始状态的时候或者左边为左括号的时候才能添加左括号
            if (s1.toString().equals("0") || s1.toString().equals("-0")) { //如果是初始状态
                s1.deleteCharAt(s1.length() - 1);
                s1.append("(");
            }
            else if (s1.charAt(s1.length() - 1) == '(') //
                s1.append("(");
            operator = false;
        }

        //判断右括号
        if (e.getSource().equals(rightPer)) {
            if (!start || s1.charAt(0) == 'E') {
                s1.delete(0, s1.length());
                s1.append("0");
                s2.delete(0, s2.length());
            }
            start = true;
            //前面必须是数字或右括号才能添加
            if (Character.isDigit(s1.charAt(s1.length() - 1)) || s1.charAt(s1.length() - 1) == ')')
                s1.append(")");
            operator = false;
        }

        //判断根号
        if (e.getSource().equals(radicalSign)) {
            if (s1.charAt(0) == 'E')
                return ;
            start = false;
            //删除无用的数据
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            if (s1.length() == 0)
                s1.append("0");
            String str = new Calculator(s1.toString()).Calculated();//先计算出s1中的表达式
            s2.delete(0, s2.length());
            s2.append(s1);
            s1.delete(0, s1.length());
            s2.insert(0, "√(");
            if (str.equals("Error!") || Double.parseDouble(str) < 0) //如果表达式有错误或结果为负数
                s1.append("Error!");
            else {
                double s = Double.parseDouble(str);
                s1.append(Math.sqrt(s));
            }
            s2.append(")");
            operator = false;
        }

        //判断等号
        if (e.getSource().equals(equal)) {
            if (s1.charAt(0) == 'E')
                return ;
            start = false;
            //删除无用的数据
            while (s1.length() > 0 && (s1.charAt(s1.length() - 1) == '(' || s1.charAt(s1.length() - 1) == '.')) {
                s1.deleteCharAt(s1.length() - 1);
            }
            //如果s1为空，补0
            if (s1.length() == 0)
                s1.append("0");
            String str = new Calculator(s2.append(s1.toString()).toString()).Calculated(); //计算
            if (!str.equals("Error!")) //不是错误信息
                s2.append( "=" + str);
            else s2.append("=");
            s1.delete(0, s1.length());
            s1.append(str);
            operator = false;
        }
        inputText.setText(s1.toString()); //添加到输入框
        resultLabel.setText(s2.toString()); //添加到结果标签
    }
}

END

至此，带有图形化的计算器就已经完成了，代码可以查看GitHub仓库。

由于本人是一个小白，有错误的地方可以在下方评论区留言或私信我，我们可以相互讨论~~.

你可能感兴趣的:(Java,#,Java,SE)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • 网易严选官方旗舰店，优质商品，卓越服务 高省_飞智666600
    网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • Git常用命令－修改远程仓库地址 猿大师 LinuxJavagitjava
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • Faiss Tips：高效向量搜索与聚类的利器 焦习娜Samantha
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • scala的option和some 矮蛋蛋 编程scala
    原文地址： http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
  • NullPointerException Cb123456 androidBaseAdapter
        java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference     出现以上异常.然后就在baidu上
  • PHP使用文件和目录 天子之骄 php文件和目录读取和写入php验证文件php锁定文件
    PHP使用文件和目录 1.使用include()包含文件 (1)：使用include()从一个被包含文档返回一个值 (2)：在控制结构中使用include()   include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。   在php.ini文件中设置
  • SQL SELECT DISTINCT 语句 何必如此 sql
    SELECT DISTINCT 语句用于返回唯一不同的值。 SQL SELECT DISTINCT 语句 在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 DISTINCT 关键词用于返回唯一不同的值。 SQL SELECT DISTINCT 语法 SELECT DISTINCT column_name,column_name F
  • java冒泡排序 3213213333332132 java冒泡排序
    package com.algorithm; /** * @Description 冒泡 * @author FuJianyong * 2015-1-22上午09:58:39 */ public class MaoPao { public static void main(String[] args) { int[] mao = {17,50,26,18,9,10
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！ 7454103 DAOspringAjaxjsonqq
    struts2.18  出来有段时间了！ （貌似是 稳定版）   闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！   实践了下下！ 不当之处请绕过！ 呵呵   网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar   strut
  • struts2 数据标签说明 darkranger jspbeanstrutsservletScheme
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 数据标签主要包括： action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
  • 链表.简单的链表节点构建 aijuans 编程技巧
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" #define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} typedef struct node {  &nbs
  • tomcat下jndi的三种配置方式 avords tomcat
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。          tomcat配置
  • 关于敏捷的一些想法 houxinyou 敏捷
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 感觉表达的不太清楚。 感觉容易被人误解的地方主要在“用户多变的需求”上。 第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
  • 富养还是穷养，决定孩子的一生 bijian1013 教育人生
    是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由 事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
  • oracle 日期时间格式转化 征客丶 oracle
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； SYSDATE：不支持毫秒，取的是系统时间； SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 日期转字符窜： 一、不取毫秒： TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 简要说明， YYYY 年 MM   月
  • 【Scala六】分析Spark源代码总结的Scala语法四 bit1129 scala
    1. apply语法   FileShuffleBlockManager中定义的类ShuffleFileGroup，定义：   private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) { ... def apply(bucketId
  • Erlang中有意思的bug bookjovi erlang
      代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b Author: Jovi Zhang <[email protected]> Date: Fri Dec 2 16:19:22 2011 +0100 erts:
  • 移位打印10进制数转16进制-2008-08-18 ljy325 java基础
    /** * Description 移位打印10进制的16进制形式 * Creation Date 15-08-2008 9:00 * @author 卢俊宇 * @version 1.0 * */ public class PrintHex { // 备选字符 static final char di
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 利用cmd命令将.class文件打包成jar chenyu19891124 cmdjar
    cmd命令打jar是如下实现： 在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： cd D: 回车 cd workspace/prpal
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 comsci eclipse设计模式算法工作swing
                           JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明     &nb
  • SecureCRT右键粘贴的设置 daizj secureCRT右键粘贴
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 菜单： Options->Global Options ...->Terminal 右边有个Mouse的选项块。 Copy on Select Paste on Right/Middle
  • Linux 软链接和硬链接 dongwei_6688 linux
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
  • DIV底部自适应 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • Centos6.5使用yum安装mysql——快速上手必备 dcj3sjt126com mysql
    第1步、yum安装mysql [root@stonex ~]#  yum -y install mysql-server 安装结果： Installed:     mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
  • 如何调试JDK源码 frank1234 jdk
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 下面是编译jdk的具体步骤：         1.把C:\java\jdk1.6.0_26\sr
  • Maximal Rectangle hcx2013 max
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.   public class Solution { public int maximalRectangle(char[][] matrix)
  • Spring MVC测试框架详解——服务端测试 jinnianshilongnian spring mvc test
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。   Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 &nbs
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0 liyong0802 hadoop
    一、准备编译软件   1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。     环境变量设置如下：   （1）执行vim /etc/profile （2）在文件尾部加入: export JAVA_HOME=/home/spark/jdk1.7 export MAVEN_HOME=/ho
  • StatusBar 字体白色 pangyulei status
    [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent]; /*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
  • 如何分析Java虚拟机死锁 sesame javathreadoracle虚拟机jdbc
    英文资料： Thread Dump and Concurrency Locks   Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
  • 位运算简介及实用技巧（一）：基础篇 tw_wangzhengquan 位运算
    http://www.matrix67.com/blog/archives/263    去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
  • jsearch的索引文件结构 yangshangchuan 搜索引擎jsearch全文检索信息检索word分词
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。   jsearch的索引文件结构定义如下：     1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他