java使用stack栈实现简单四则计算器

        首先主类Calculate实现的功能比较简单,简单的控制台输入和调用真正的计算方法

public class Calculate {
    public static void main(String[] args) {
        //控制台输入计算表达式
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();


        //计算
        int result = Operation.calculate(str);
        System.out.println(result);


    }
}

        接下来是实现主要计算功能的类

import java.util.*;

public class Operation {


    //创建两个栈分别存放数字和运算符,存放数字的栈由于要做数字拼接所以使用string类型
    public static Stack<String> nums = new Stack<>();
    public static Stack<String> ops = new Stack<>();

    //计算结果
    public static int result = 0;

    //创建两个栈用来存放乘除算法过后的剩余的加减法运算符和数字
    public static Stack<Integer> afterNums = new Stack<>();
    public static Stack<String> afterops = new Stack<>();


    /**
     *计算方法
     * @param str
     * @return
     */
    public static int calculate(String str) {
        //分割输入的算法表达式,并存入集合中
        String[] strs = str.split("");
        List<String> strList = Arrays.asList(strs);

        //将计算结果初始化为0
        int result = 0;

        //解析运算式,分离数字和操作符
        putStack(strList);

        //计算表达式中的乘法
        int temp_result = calculate();

        //计算表达式中的加减法
        while (!afterops.isEmpty()){
            String op = afterops.pop();
            switch (op){
                case "+":
                    temp_result = temp_result + afterNums.pop();
                    break;
                case "-":
                    temp_result = temp_result - afterNums.pop();
                    break;
            }
        }
        result = temp_result;
        return result;
    }

    /**
     * 优先计算表达式中的乘法
     * @return
     */
    private static int calculate(){
        //用于存放计算中的临时数据
        String temp;
        while (!ops.isEmpty()){
            String op = ops.pop();
            switch (op){
                case "*":
                    //计算并将计算结果赋值给temp重新压入栈中
                    result = Integer.parseInt(nums.pop()) * Integer.parseInt(nums.pop());
                    temp = String.valueOf(result);
                    nums.push(temp);
                    break;
                case "/":
                    //这里要注意除数和被除数的位置,所以需要先取出除数和被除数
                    String divider = nums.pop();
                    String dividend = nums.pop();
                    result = Integer.parseInt(dividend) / Integer.parseInt(divider);
                    temp = String.valueOf(result);
                    nums.push(temp);
                    break;
                case "+":
                case "-":
                    //将加减法符号存入新符号栈中,并将操作符后面一个数放入新数字栈
                    afterNums.push(Integer.parseInt(nums.pop()));
                    afterops.push(op);
                    break;
            }
        }

//        返回栈中剩余的最后一个结果
        return Integer.parseInt(nums.pop());

    }


    /**
     * 将数字与运算符分割开来并放入各自的栈中
     * @param strList
     */
    private static void putStack(List<String> strList) {


        //定义一个boolean变量用来判断上一个存入栈中的元素是否是数字,是数字的话则会拼接当前的数字
        boolean flag = false;
        demo:for (int i = 0; i < strList.size(); i++) {
            //取当前运算式的第一个字符
            String s = strList.get(i);

            //判断字符是否是数字
            if (Character.isDigit(s.charAt(0))) {
                if (flag){
                    s = nums.pop() + s;
                }

                //为数字将其放入数字栈中
                nums.push(s);
                flag=true;
            }else {

                //字符为运算符,放入操作符栈中
                switch (s) {
                    case "+":
                    case "-":
                    case "*":
                    case "/":
                        ops.push(s);
                        flag=false;
                        break;
                    default:
                        //表达式不正确中断整个操作
                        System.out.println("输入的表达式不正确");
                        flag=false;
                        break demo;
                }
            }
        }
    }


}

        运行结果:

 

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
波兰计算器是一种前缀表达式的计算方法,可以用实现。下面是Java实现波兰计算器的示例代码: ```java import java.util.Stack; public class PolishCalculator { public static void main(String[] args) { String expression = "+ 5 * 4 3"; int result = calculate(expression); System.out.println("计算结果:" + result); } public static int calculate(String expression) { String[] elements = expression.split(" "); Stack<Integer> stack = new Stack<>(); for (int i = elements.length - 1; i >= 0; i--) { String element = elements[i]; if (isOperator(element)) { int a = stack.pop(); int b = stack.pop(); int result = calculate(b, a, element); stack.push(result); } else { int num = Integer.parseInt(element); stack.push(num); } } return stack.pop(); } public static boolean isOperator(String str) { return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/"); } public static int calculate(int a, int b, String operator) { switch (operator) { case "+": return a + b; case "-": return a - b; case "*": return a * b; case "/": return a / b; default: throw new IllegalArgumentException("不支持的操作符:" + operator); } } } ``` 上述代码中,我们首先定义了一个`calculate`方法,用来计算传入的前缀表达式的值。在方法中,我们先将表达式按照空格分割成字符串数组,然后从后向前遍历数组中的每个元素。如果当前元素是操作符,则从中弹出两个数进行计算,并将计算结果压入中;如果当前元素是数字,则将其转换成整型并压入中。最后,从中弹出最后一个元素作为计算结果返回。 我们还定义了一个`isOperator`方法,用来判断传入的字符串是否是操作符。另外,我们还定义了一个`calculate`方法,用来根据传入的两个数和操作符进行计算,并返回计算结果。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值