java 计算加 java计算加减法算式结果

题目类别: 实验

关键字: 类、对象、封装、类之间的关系、字符串

内容要求:

1 . 编写一个Java应用程序。

2 . 要求实现功能如下：

  (1) 从键盘输入一个表示整数四则运算的字符串，例如：32+5*2-40/3

    四则运算符号：

    +代表整数加法、-代表整数减法、*代表整数乘法、/代表整数除法（结果为整数）

    运算数全部为正整数

    表达式中没有括号

  (2) 程序按照四则运算符的优先级和结合性对表达式进行分析并产生输出结果。

3 . 运行示例：

输入：32+5*2-40/3

输出：29

4 . 程序设计要求使用面向对象方法编写。

备注

打包为可以执行的JAR文档，其中要包含源程序文件。

实现代码：

Expression类

package cn.scau.module;

import cn.scau.utils.CalculateUtil;

import java.util.ArrayList;

/**
 * @author zg
 */
public class Expression {
    /**
     * 表达式
     */
    private String expression;

    public Expression() {
        this("");
    }

    public Expression(String expression) {
        this.expression = expression;
    }

    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }


    /**
     *
     * @return 表达式的结果
     */
    public int calculate() {
        ArrayList<String> entries = CalculateUtil.divideIntoEntries(this.expression);
        ArrayList<String> addEntries = CalculateUtil.calculateMultiAndDiv(entries);
        return CalculateUtil.calculatePlusAndMinusOnly(addEntries);
    }

}

CalculateUtil类

package cn.scau.utils;

import java.util.ArrayList;

/**
 *
 * 计算工具类
 *
 * @author zg
 */
public class CalculateUtil {

    /**
     *
     * @param expression 表达式
     * @return 拆分项和符号，将其存入数组中
     */
    public static ArrayList<String> divideIntoEntries(String expression) {
        char[] str = expression.toCharArray();
        ArrayList<String> lists = new ArrayList<>();
        StringBuilder list = new StringBuilder();

        //
        for (char c : str) {
            if (c == '+' || c == '-' || c == '*' || c == '/') {
                //  如果是运算符，单独作为一个元素存进数组中;清空list
                if(!list.isEmpty()){
                    lists.add(list.toString());
                }
                lists.add("" + c);
                list = new StringBuilder();
            } else {
                //  如果不是运算符，将其加到list的末尾
                list.append(c);
            }
        }
        //  加上最后一项
        lists.add(list.toString());
        return lists;
    }

    /**
     *
     * @param lists 只含有项和运算符的数组
     * @return 只包含项、"+"和"-"的数组
     */
    public static ArrayList<String> calculateMultiAndDiv(ArrayList<String> lists) {
        ArrayList<String> newLists = new ArrayList<>();
        for (int i = 0; i < lists.size(); i++) {
            if ("*".equals(lists.get(i))) {
                // 如果是"*"运算符，*号前后两个数相乘;把所得结果放进新的数组中
                newLists.add(String.format("%d",
                        (Integer.parseInt(lists.get(i - 1)) * Integer.parseInt(lists.get(i + 1)))));
            } else if ("/".equals(lists.get(i))) {
                // 如果是"/"运算符，/号前后两个数相除;把所得结果放进新的数组中
                newLists.add(String.format("%d",
                        (Integer.parseInt(lists.get(i - 1)) / Integer.parseInt(lists.get(i + 1)))));
            } else if ("-".equals(lists.get(i)) || "+".equals(lists.get(i))) {
                //  如果是"+"或者"-"运算符,直接将其放进数组中
                newLists.add(lists.get(i));
            } else if (i >= 1 && i < lists.size() - 1) {
                //  中间项，如果中间项后面的符号不是"*"或者"/",直接将其放进数组中
                if (!"*".equals(lists.get(i - 1)) && !"/".equals(lists.get(i - 1)) && !"*".equals(lists.get(i + 1)) && !"/".equals(lists.get(i + 1))) {
                    newLists.add(lists.get(i));
                }
            } else if (i == 0) {
                //  如果是首项，如果首项后面的符号不是"*"或者"/",直接将其放进数组中
                if (!"*".equals(lists.get(i + 1)) && !"/".equals(lists.get(i + 1))) {
                    newLists.add(lists.get(i));
                }
            } else {
                //  末尾项，如果末尾项前面的符号不是"*"或者"/",直接将其放进数组中
                if (!"*".equals(lists.get(i - 1)) && !"/".equals(lists.get(i - 1))) {
                    newLists.add(lists.get(i));
                }
            }
        }
        return newLists;
    }

    /**
     *
     * @param newLists 只包含项、"+"和"-"的数组
     * @return 整型运算结果
     */
    public static int calculatePlusAndMinusOnly(ArrayList<String> newLists){
        //  第一项为正整数
        int count= "-".equals(newLists.get(0))?0:Integer.parseInt(newLists.get(0));
        for(int i=0;i<newLists.size();i++){
            if("+".equals(newLists.get(i))){
                //  如果只"+"号，结果加上符号后的项
                count+=Integer.parseInt(newLists.get(i+1));
                //  跳过已被加上的项
                i++;
            }else if("-".equals(newLists.get(i))){
                //  如果只"-"号，结果减去符号后的项
                count-=Integer.parseInt(newLists.get(i+1));
                //  跳过已被减去的项
                i++;
            }
        }
        return count;
    }
}

Main类

package cn.scau.main;

import cn.scau.module.Expression;

import java.util.Scanner;

/**
 * @author zg
 */
public class Main {
    public static void main(String[] args) {
        System.out.print("输入:");
        String expression=new Scanner(System.in).next();
        Expression exp = new Expression(expression);
        System.out.println("输出:"+exp.calculate());
    }
}

---

---

---

最后的ExpressionTest类用于数据测试：

package cn.scau.test;

import cn.scau.module.Expression;
import cn.scau.utils.CalculateUtil;
import org.junit.Test;

import java.util.ArrayList;

/**
 * @author zg
 */
public class ExpressionTest {
    @Test
    public void test(){
        System.out.println("exp1:");
        ArrayList<String> en = CalculateUtil.divideIntoEntries("-1-2-3");
        for (String s : en) {
            System.out.println(s);
        }
        Expression expression = new Expression("-1-2-3");
        System.out.println("-1-2-3="+expression.calculate());

        System.out.println("exp2:");
        ArrayList<String> en2 = CalculateUtil.divideIntoEntries("32+5*2-40/3");
        for (String s : en2) {
            System.out.println(s);
        }
        Expression expression2 = new Expression("32+5*2-40/3");
        System.out.println("32+5*2-40/3="+expression2.calculate());
    }
}