【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：