计算字符串算数表达式

试了下，第一个数字判断是不是负数和负数有没有在括号后面这些条件不加也是能过的。

import java.util.*;

public class Main{
    static Stack<Integer> num=new Stack<>();
    static Stack<Character>  signs=new Stack<>();        

    static boolean isNum(char c) { //判断字符是不是0-9的数字
        if(c>='0'&&c<='9')
            return true;
        return false;
    }

    static boolean isSign(char c){  //判断是不是非括号的操作符
        if(c=='+'||c=='-'||c=='*')
            return true;
        return false;
    }

    static boolean checkFirst(char[] c) { //字符串转化为字符数组以后检查两个数字间有多个空格的情况
        if (c.length<2&&isNum(c[0]))    //如果只有1个数字的情况
            return true;
        int i=1;
        while(i<c.length) {
            if(c[i]==' '&&isNum(c[i-1])) {    //空格前面是数字
                i++;
                while(i<c.length && c[i]==' ') { //处理多个连续空格
                    i++;
                }
                if(i<c.length && isNum(c[i])) { //i<c.length 判断数组是否越界的标志，后面会多次反复用到
                    System.out.println("Error"); //符合出错要求即输出Error
                    return false;
                }
            }
            i++;
        }
        return true;
    }

    static boolean comparePri(char c) { //判断符号优先级
            if (signs.empty()) { 
                return true;
            }           
            char top = signs.peek(); 
            if (top == '(') {    
                return true;
            }
            switch (c) {        //优先级从高到低
                case '(': 
                    return true;
                case '+': {                    
                    return top == '*';    //如果栈顶是"*"则返回真，即先不操作，因为+优先级更高，所以要到后面的数字进来，先把+pop完算了再处理*
                }
                case '-': {                   //同上
                    return top == '*';
                }
                case '*':
                    return false;
                case ')': 
                    return false;    
                default:
                    break;
            }
            return true;
        }

     static boolean isStandard(String numStr) {  //判断表达式里括号数量是否匹配以及表达式里有没有不该出现的字符
            if (numStr == null || numStr.isEmpty()) 
                return false;
            Stack stack = new Stack(); 
                if(numStr.charAt(0)=='-')
                    return false;                    //判断第一个数字是不是负数
            for (int i = 0; i < numStr.length(); i++) {
                char n = numStr.charAt(i);    
                if (!(isNum(n) ||"(".equals(n + "") || ")".equals(n + "")
                        || "+".equals(n + "") || "-".equals(n + "")
                        || "*".equals(n + "") ))
                    return false;                                               
                if ("(".equals(n + "")) {
                    stack.push(n);
                }
                if (")".equals(n + "")) { 
                    if (stack.isEmpty()) 
                        return false;
                    else stack.pop();
                }           
            }
            if (!stack.isEmpty())
                return false;
            return true;
        }
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        if(s==null||s.isEmpty()){
            System.out.println("Error");
            return;
        }
        char[] c=s.toCharArray();
        boolean flag=checkFirst(c);    //检查空格
        if(!flag) return;
        String s2=s.replaceAll(" ", "");//空格不影响结果则去掉空格    
        flag=isStandard(s2);        //检查括号、小数点
        if(!flag) {
            System.out.println("Error");
            return;
        }
        char[] c2=s2.toCharArray();
        if (isSign(c2[c2.length-1])){        //检查字符串末尾是否有操作符
             System.out.println("Error");
             return;
        }
        int i=0;
        while(i<c2.length) {
            if(isNum(c2[i])) {        //如果是数字
                int k=c2[i]-'0';
                i++;                
                while(i<c2.length&&isNum(c2[i])) {
                    k=k*10+(c2[i]-'0');    //多个数字相连的情况
                    i++;
                }                    
                num.push(k);        //存进栈里
            }

            if(i<c2.length && isSign(c2[i]) && isSign(c2[i-1])){ //两个操作符连在一起的情况(包括负数处理)
                System.out.println("Error");
                return;
            }
            if(i<c2.length&& c2[i]=='-' && c2[i-1]=='('){        //处理负数在左括号前面的情况
                System.out.println("Error");
                return;
            }

            while (i<c2.length && !comparePri(c2[i]) && !signs.empty()) {    //操作符栈不空，优先级条件满足     
             int b = num.pop(); 
             int a = num.pop();                            
             switch (signs.pop()) {
                case '+':
                   num.push(a + b);
                   break;
                case '-':
                   num.push(a - b);
                   break;
                case '*':
                   num.push(a * b);
                   break;
                default:
                break;
             }
        } 

            if(i<c2.length) {
                signs.push(c2[i]);
                if(c2[i]==')') {    //去括号
                    signs.pop();
                    signs.pop();
                }
                i++;
            }

        }
            while(!signs.empty()){        //如果操作符栈里还有操作符，则继续运算
             int b = num.pop(); 
             int a = num.pop();                            
             switch (signs.pop()) {
                case '+':
                   num.push(a + b);
                   break;
                case '-':
                   num.push(a - b);
                   break;
                case '*':
                   num.push(a * b);
                   break;
                default:
                   break;
         }        
        }
        System.out.println(num.pop());
    }
}