mini dc与简易计算器 20165235

mini dc

任务内容

本次mini dc任务就是通过补充代码来实现整型数据的后缀表达式计算

相关知识

• 通过利用堆栈这一先进后出的数据结构来实现后缀表达式的计算。通过Stack<Integer> stack建立一个为int类型的堆栈stack。可以使用stack.push();来进行压栈，stack.pop();来进行弹栈。
• 通过调用private boolean isOperator (String token)来判断按空格标记分隔好的String数据是否为运算符。
• 使用正则表达式“[0-9]+”来判断是否为字符整数类型。
• StringTokenizer类是一种可以按不同的风格对String类型数据做分隔，有两种构造方法。StringTokenizer（String s），则按照空格，换行，Tab等符号来做分隔标记。StringTokenizer（String s，String delim）则按照delimit字符序列中的任意排列来作为分隔标记。

实现代码

import java.util.Stack;
import java.util.StringTokenizer;
import java.util.*;
public class MyDC
{
    /** constant for addition symbol */
    private final char ADD = '+';
    /** constant for subtraction symbol */
    private final char SUBTRACT = '-';
    /** constant for multiplication symbol */
    private final char MULTIPLY = '*';
    /** constant for division symbol */
    private final char DIVIDE = '/';
    /** the stack */
    private Stack<Integer> stack;
   // MyDC my= new MyDC();
    public MyDC() {
        stack = new Stack<Integer>();
    }

    public int evaluate (String expr)
    {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer (expr);
        while (tokenizer.hasMoreTokens())
            {
            token = tokenizer.nextToken();
                //System.out.println(token);
            //如果是运算符，调用isOperator
            if (isOperator(token))
            {
                char []c=token.toCharArray();
                op1=stack.pop();
                //从栈中弹出操作数2
                op2=stack.pop();
                //从栈中弹出操作数1
                result=evalSingleOp(c[0],op1,op2);
                //根据运算符和两个操作数调用evalSingleOp计算result;
                stack.push(result);
                //计算result入栈;
            }
            else{
                //如果是操作数
                if(token.matches("[0-9]+")) {
                    int number=Integer.parseInt(token);
                    stack.push(number);
                }
            }
        }
        return result;
    }

    private boolean isOperator (String token)
    {
        return ( token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/") );
    }

    private int evalSingleOp (char operation, int op1, int op2)
    {
        int result = 0;

        switch (operation)
        {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }

        return result;
    }
}

代码运行截图

简易计算器

任务内容

实现一个简易计算器Calc,支持+ - x / 和%运算, 从命令行传入计算数据，Calc计算器可以进行简单的计算。

相关知识

• 要使用到堆栈的一些基本知识，通过Stack<Integer> stack=new Stack<Integer>();来建立一个int数据类型的堆栈，来存放操作数，Stack<Character> stack1=new Stack<Character>();来建立一个char数据类型的堆栈来存放运算符。
• 使用StringTokenizer fenxi=new StringTokenizer(str);来对输入的String类型的数据进行按空格进行做分隔。
• 需要通过isOperator来判断是否为运算符，通过matches()和正则表达来判断是否为操作数。

实现过程

通过命令行传入String类型的数据，然后对传入的数据进行按空格做分隔标记，然后对分隔好的String数据类进行判断是否为运算符或操作数，如果是运算符则对运算符进行压栈（压入stack1），如果是操作数就i++，并且对操作数进行压栈（压入stack）i++，当i=2时就说明stack栈中已经压入两个操作数，所以stack进行两次弹栈，stack1进行一次弹栈，然后调用函数int evalSingleOp (char operation, int op1, int op2);来计算结果，最后将结果返回。

实现代码

import java.io.IOException;
import java.util.*;
public class CalczOperator  {
    /** constant for addition symbol */
    private final char ADD = '+';
    /** constant for subtraction symbol */
    private final char SUBTRACT = '-';
    /** constant for multiplication symbol */
    private final char MULTIPLY = 'x';
    /** constant for division symbol */
    private final char DIVIDE = '/';
    /** constant for MOD symbol */
    private final char MOD = '%';
    /** the stack */
    Stack<Integer> stack=new Stack<Integer>();
    Stack<Character> stack1=new Stack<Character>();
     int operate(String str)throws IOException {
        int op1,op2,result=0;
        int i=0;
        String string;
        StringTokenizer fenxi=new StringTokenizer(str);
        while (fenxi.hasMoreTokens())
        {
            string = fenxi.nextToken();
            //如果是运算符，调用isOperator
            if (isOperator(string))
            {
                char c[]=string.toCharArray();
                stack1.push(c[0]);
            }
            else{
                //如果是操作数
                if(string.matches("[0-9]+")) {
                    i++;
                    int number=Integer.parseInt(string);
                    stack.push(number);
                    if(i==2){
                        op1=stack.pop();
                        op2=stack.pop();
                        result=result=evalSingleOp(stack1.pop(),op2,op1);
                    }
                }
            }
        }
        return result;
    }
private int evalSingleOp (char operation, int op1, int op2)
        {
        int result = 0;

        switch (operation)
        {
        case ADD:
        result = op1 + op2;
        break;
        case SUBTRACT:
        result = op1 - op2;
        break;
        case MULTIPLY:
        result = op1 * op2;
        break;
        case DIVIDE:
        result = op1 / op2;
        break;
        case MOD:
        result = op1 % op2;
        break;
        }

        return result;
        }
 private boolean isOperator (String token)
    {
        return ( token.equals("+") || token.equals("-") ||
                token.equals("x") || token.equals("/") ||token.equals("%"));
    }

}

import java.io.IOException;
public class Calc  {
    public static void main (String args[]){
        try {
            CalczOperator calczoperator = new CalczOperator();
            String[] prt = new String[args.length];
            for(int i =0;i<args.length;i++){
                prt[i] = args[i];
            }
            String str = prt[0]+" "+prt[1]+" "+prt[2]
            int result = calczoperator.operate(str);
            System.out.println(str + " = " + result);
        }
        catch (IOException e){
            System.out.println("error");
        }
    }
}

代码运行截图：

遇到的问题以及解决过程

当运行代码java Calc 3 * 2，时报错，对其他的运算符都能正常运行出结果，只有*运算符不可以，我在Ubuntu和Windows的命令行中都运行了一遍，但都会报错。



我通过JDB调试，print args[]中的数值时，args[1]，args[2]的数据出错。

所以我认为传入的数据中含有*的原因，所以我用x代替了*进行传值。最后结果正常。

代码链接

• 简易计算器代码链接
• mini dc代码链接

心得体会

在做简易计算器和mini dc程序时，主要是对堆栈这一数据结构的灵活使用，以后多多练习，可以写出四则混合运算，把计算优先级考虑进去。