Java實驗12 整數算術表示式分析程式

阿新 • • 發佈：2020-12-25

技術標籤：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());
    }
}