简单的非通用计算器

这是用来交课间做业的，所以没有通用性，功能也只是简单+和-

而且因为是要求放到安卓上的，因此输入只是容许单个 0 - 9 和 +-，当=时计算，或者BACK!时撤回上一步

没啥优雅的写法啊，只是既然花了时间，那总得记录一下这糟糕的过程吧

UPD.更新了支持加减乘除的版本，使用逆波兰表达式，实现上较暴力

StringUtil类，用了个简单的正则（放弃小数点了。。）

package com.cal;

public class StringUtil {
    
    private StringUtil() {}
    
    static public boolean hasLength(String str) {
        return str != null && !"".equals(str);
    }
    
    // 默认输入只有 0-9 + -
    static public boolean isNum(String str) {
        if(!hasLength(str)) {
            return false;
        }
//        return str.matches("\\d*\\.?\\d+");
        return str.matches("\\d+");
    }
        
    static public boolean isOperator(String str) {
        if(!hasLength(str)) {
            return false;
        }
        return !isNum(str) && !".".equals(str); // .暂时废弃
    }
}

CalExpression类，用于处理输入语法表达式的简单缓冲（方便回退操做）及格式化

package com.cal;

import java.util.ArrayList;

public class CalExpression {
    
    private StringBuilder expression;
    private ArrayList<String> inputRecord;
    
    public CalExpression() {
        expression = new StringBuilder();
        inputRecord = new ArrayList<>();
    }
    
    public void next(String input) {
//        if(StringUtil.isNum(input)) {
//            expression.append(input);
//        } else if(inputRecord.size() == 0) {
//            expression.append(input + " ");
//        } else {
//            expression.append(" " + input + " ");
//        }
        inputRecord.add(input);
    }
    public void back() {
        if(inputRecord.size() == 0) return;
        inputRecord.remove(inputRecord.size()-1);
    }
    
    public String done() {
        for(int i = 0; i < inputRecord.size(); i++) {
            String elem = inputRecord.get(i);
            if(".".equals(elem)) {
                expression.append(elem);
            } else if(StringUtil.isNum(elem)) {
                expression.append(elem);
            } else if(inputRecord.size() == 0) {
                expression.append(elem + " ");
            } else {
                expression.append(" " + elem + " ");
            }
        }
        return expression.toString();
    }
    
    public String toString() {
        return expression.toString();
    }
    
}

Calculator类，真正用于计算逻辑和判断恶心错误

package com.cal;

// 本计算姬目前已经支持 + - 和判断式子正确的能力
// 下一步增长撤回一格的操做 // OK!
// 下下一步增长小数点的支持 // 太麻烦啦!
// 下下下一步增长 x / 括号的支持
public class Calculator {
    
    private String expression;
    private boolean validExpression;
    
    public Calculator() {
        validExpression = false;
        expression = new String();
    }
    
    public Calculator(CalExpression expression) {
        this.expression = expression.done();
        validExpression = check();
    }
    
    public boolean setExpression(CalExpression exp) {
        this.expression = exp.done();
        validExpression = check();
        return validExpression;
    }
    
    public int calculate() {
        if(!check()) {
            validExpression = false;
            return -1;
        } else {
            return getAnswer();
        }
    }
    
    public boolean check() {
        if(!StringUtil.hasLength(expression)) {
            return false;
        }
        String[] elems = expression.split(" ");
        boolean lastIsOp = false;
        for(int i = 0; i < elems.length; i++) {
            
            String elem = elems[i];
            
//            System.out.println("{"+elem+"}");
            
            if(StringUtil.hasLength(elem) == false) {
                continue;
            }
            if(StringUtil.isOperator(elem) && lastIsOp) {
                return false;
            }
            if(i == elems.length-1 && StringUtil.isOperator(elem)) {
                return false;
            }
            lastIsOp = StringUtil.isOperator(elem) ? true : false;
        }
        return true;
    }
    
    protected boolean isVaild() {
        return validExpression;
    }
    
    public int getAnswer() {
        if(!StringUtil.hasLength(expression)) {
            return -1;
        }
//        System.out.println(Character.toString(expression.charAt(0)));
        if(StringUtil.isOperator(Character.toString(expression.charAt(0)))) { // 修正负号问题
            expression = "0 " + expression;
        }
        int ans = 0, lastOp = 1;
        String[] elems = expression.split(" ");
        for(int i = 0; i < elems.length; i++) {
            String elem = elems[i];
            if(StringUtil.isNum(elem)) {
                ans += lastOp * Integer.valueOf(elem);
            } else {
                lastOp = "+".equals(elem) ? 1 : -1;
            }
        }
        return ans;
    }

    public String getExpression() {
        return String.join("", expression.split(" "));
    }
    
    public String toString() {
        return getExpression();
    }
    
}

输入类，上课时把它换掉android逻辑就ok了

package com.cal;

import java.util.Scanner;


public class InputExpression {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        Calculator cal = new Calculator();
        CalExpression exp = new CalExpression();
        while(cin.hasNext()) {
            String input = cin.next();
            if(input.contentEquals("BACK!")) {
                exp.back();
            } else if(input.equals("=")) {
                cal.setExpression(exp);
                System.out.println("exp: " + exp.toString());
                System.out.println("cal: " + cal.toString());
                if(cal.isVaild() == false) {
                    System.out.println("Please input correctly");
                } else {
                    System.out.println(cal.getAnswer());
                }
                cal = new Calculator();
                exp = new CalExpression();
            } else {
                exp.next(input);
            }
        }
        cin.close();
    }
}

暴力V2

package com.lpy.calculator;

import java.util.Scanner;
import java.util.Stack;

public class CalculatorExpression {
    
    public static Stack<Character> st_ch;
    public static Stack<Double> st_num;
    
    public static void cal1() {
        char ch = st_ch.peek();
        while(ch != '(') {
            double num1 = st_num.pop();
            double num2 = st_num.pop();
            switch(ch) {
            case '+':
                num2 += num1;
                break;
            case '-':
                num2 -= num1;
                break;
            case '*':
                num2 *= num1;
                break;
            case '/':
                num2 /= num1;
                break;
            default:
                break;
            }
            st_num.push(num2);
            st_ch.pop();
            ch = st_ch.peek();
        }
    }
    
    public static void cal2() {
        char ch = st_ch.peek();
        while(ch == '*' || ch == '/') {
            double num1 = st_num.pop();
            double num2 = st_num.pop();
            switch(ch) {
            case '*':
                num2 *= num1;
                break;
            case '/':
                num2 /= num1;
                break;
            default:
                break;
            }
            st_num.push(num2);
            st_ch.pop();
            ch = st_ch.peek();
        }
    }
    

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);       
        while(sc.hasNext()) {
            st_ch = new Stack<>();
            st_num = new Stack<>();
            st_ch.push('(');
            String str = sc.next();
            try {
                StringBuilder str_num = new StringBuilder("");
                for(int i = 0; i < str.length(); i++) {
                    String ch = Character.toString(str.charAt(i));
                    if(ch.matches("\\d") || ".".equals(ch)) {
                        str_num.append(ch);
                        continue;
                    }
                    if("".equals(str_num.toString()) == false) {
                        st_num.push(Double.valueOf(str_num.toString()));
                        str_num = new StringBuilder("");
                    }
                    switch(str.charAt(i)) {
                    case '+':
                    case '-':
                        cal1();
                        st_ch.push(str.charAt(i));
                        break;
                    case '*':
                    case '/':
                        cal2();
                        st_ch.push(str.charAt(i));
                        break;
                    case '(':
                        st_ch.push('(');
                        break;
                    case ')':
                    case '=':
                        cal1();
                        st_ch.pop();
                        break;
                    }
                }
                System.out.println(st_num.pop());
            } catch(Exception e) {
                System.out.println("Error!");
            }
        }
        sc.close();
    }
}