【week3】四则运算 单元测试

上一周的四则运算有bug，这次补充正确代码：

// 中缀转后缀
public String[] SolveOrder(String[] in, HashMap<String, Integer> precedence) {
        // 符合逆波兰式（后缀）的输出
        int kk=in.length;
        String out[] = new String[kk];
        int p = 0 ;
        // 操作符
        Stack<String> ops = new Stack<String>();
        for (int i = 0; i < in.length; i++) {
            String s = in[i];
            // 碰见数值 就放进out数组末尾
            if (!precedence.containsKey(in[i])) {
                out[p] = s ;
                p ++ ;
                continue;
            }
            //如果优先级比栈顶的大
            if (ops.isEmpty() || (precedence.get(s) > precedence.get(ops.peek()))) {
                    ops.push(s);
                    //break;
            }else{
                        //如果栈顶的比目前的运算符优先级小或者相等 一直出栈到没有或者栈顶    小于当前运算符
                while (true ) {
                    ops.pop();// 出栈得运算符
                    out[p] = s ;
                    p ++ ;
                    if(ops.empty())  break ;//如果栈空了  break
                    if(precedence.get(ops.peek()) < precedence.get(s)){
                        break ;//栈顶小于当前的了  break
                    }
                }
                out[p] = s ;
                p ++ ;
            }
        }
        // 若操作符栈不为空，就依次将剩余的操作符放入out数组
        while (!ops.isEmpty()) {
            out[p] = ops.peek() ;
            p ++ ;
            ops.pop() ;
        }
        return out;
    }

    // 优先级的定义
    public HashMap<String, Integer> priorityInfo() {
        HashMap<String, Integer> precedence = new HashMap<String, Integer>();
        precedence.put("(", 0);
        precedence.put(")", 0);
        precedence.put("+", 1);
        precedence.put("-", 1);
        precedence.put("*", 2);
        precedence.put("/", 2);
        return precedence;
    }

    public double calculateOut(String[] out) {
        // 假设满足逆波兰式的输出不为空却长度不为零
        int kk=out.length;
        System.out.println("转换成后缀表达式是");
        for(int o=0;o<kk;o++){
            System.out.print(out[o]);
        }
        System.out.println();
        assert (out != null && out.length != 0);
        // 操作数栈
        Stack<Double> stack = new Stack<Double>();
        for (int i = 0; i < out.length; i++) {
            if (isNumber(out[i])) {
                stack.push(Double.parseDouble(out[i]));
            } else {
                double v1 = stack.pop();
                double v2 = stack.pop();
                double result = eval(out[i], v2, v1);
                stack.push(result);
            }
        }
        return stack.pop();
    }

    // 判别是否是数字
    public boolean isNumber(String s) {
        if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/"))
            return false;
        return true;
    }

    public static double eval(String op, double val1, double val2) {
        if (op.equals("+"))
            return val1 + val2;
        if (op.equals("-"))
            return val1 - val2;
        if (op.equals("/"))
            return val1 / val2;
        if (op.equals("*"))
            return val1 * val2;
        throw new RuntimeException("Invalid operator");
    }
    public static void main(String[] args) {
        System.out.println("请输入要计算的算式：");
        Scanner sc = new Scanner(System.in);
        String inBefore = sc.nextLine();
        String[] in = inBefore.split("") ;
        int kk=in.length;
        System.out.println("您输入的算式是");
        for(int o=0;o<kk;o++){
            System.out.print(in[o]);
        }
        System.out.println();
        Cal cc = new Cal() ;
        HashMap<String, Integer> precedence = cc.priorityInfo();
        String[] out = cc.SolveOrder(in, precedence);
        System.out.println("所输入的算式结果为:" + cc.calculateOut(out));

}            

运行结果如下：

单元测试代码如下：

测试中缀转后缀

        Cal c1=new Cal();
	String inBefore = "1+2*3";
	String[] in = inBefore.split("") ;

	
	@Test
	public void testSolveOrder() {
		HashMap<String, Integer> precedence = new HashMap<String, Integer>();
		precedence.put("(", 0);
		precedence.put(")", 0);
		precedence.put("+", 1);
		precedence.put("-", 1);
		precedence.put("*", 2);
		precedence.put("/", 2);
		assertEquals("123*+", c1.SolveOrder(in, precedence));
		fail("Not yet implemented");
	}

 测试计算结果是否正确

@Test
public void testCalculateOut() {
　　assertEquals("7.0", c1.calculateOut(in));
}

 测试是否是数字：

@Test
public void testIsNumber() {
	assertEquals("1", "1");
	assertEquals("0", "+");
}

 测试Eval（）单步计算结果：

@Test
public void testEval() {
	assertEquals("5", c1.eval("+", 3, 2));
	assertEquals("6", c1.eval("*", 3, 2));
	assertEquals("1", c1.eval("-", 3, 2));
	assertEquals("2", c1.eval("/", 6, 3));
}

 运行结果如下：

现在实现的手动输入字符串算式，scanner识别，拆分在进行计算。

四则运算psp：