软件工程概论个人作业2

  老师有将上次的作业进行了功能上的升级，加入了新的功能，所以我就将我的作业设计再次展示。

  程序设计思路：上次的程序设计只是简单的两个数的四则运算，不需要对运算符的种类进行筛选，这次的作业我将上次的程序设计代码，进行了重新封装，设计了一个输入数据的方法，对不同的输入数据进行不同要求的生成式子，并对程序生成的式子进行判断是否符合标准。对符合要求的式子存放在string数组中，然后在数组中的式子输出到结果即可。

  程序源代码：

package 四则运算;

import java.util.Scanner;

public class yunsuan {

    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String array1[]=new String[1000];
        input(array1);

    }
    public static void input(String array1[]){
        int a,b,c,d,e,f;
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入生成题目的数量（少于1000道）：");
        a=scanner.nextInt();
        System.out.println("请输入数字的范围（1-？）：");
        b=scanner.nextInt();
        System.out.println("是否有乘除法(包含乘除法请输入1，不包含请输入0)");
        c=scanner.nextInt();
        System.out.println("是否有括号(最多可以支持十个数参与计算,包含括号请输入1，不包含请输入0)");
        d=scanner.nextInt();
        System.out.println("加减有无负数(有负数请输入1，没有负数请输入0)");
        e=scanner.nextInt();
        System.out.println("除法有无余数(有余数请输入1，没有余数请输入0)");
        f=scanner.nextInt();
        int m;
        boolean n,o,p;
        if(c==1)
            m=4;
        else m=2;
        if(d==1)
            n=true;
        else n=false;
        if(e==1)
            o=true;
        else o=false;
        if(f==1)
            p=true;
        else p=false;
        for(int i=0;i<a;i++){
            array1[i]=birth(b,m,n,o,p);
        }
        output(a,array1);
    }

    public static void output(int a,String []array1 ){
        for(int i=0;i<a;i++){
            System.out.println(array1[i]);
        }
    }
    public static String birth(int fanwei,int fuhao,boolean bra,boolean o,boolean p){
        int a=((int)(Math.random()*9))+2;
        int b,c;
        String str ="";
        for(int i=0;i<a;i++){
            b=(int)(Math.random()*fanwei)+1;
            c=(int)(Math.random()*fuhao);
            if(i==a-1)
                 str+=b+"=";
            else {
                switch(c){
                case 0: str+=b+"+";break;
                case 1: str+=b+"-";break;
                case 2: str+=b+"*";break;
                case 3:    str+=b+"/";break;
                }
                
            }
            
        }
        if(bra&&((int)( Math.random()*100))>50){
            //在这里为express中插入一对括号
            
            int first = (int)(Math.random()*(a-1))+1;//括起来的第一个数
            int next = (int)(Math.random()*(a-1))+1;//括起来的最后一个数
            if(first > next){//如果第一个数比第二个数大，则交换两个数的值
                first = first^next;
                next = first^next;
                first=first^next;
            }
            if(next-first >= 2){//如果next和first的差值小于2，则不执行以下步骤，因为括号中至少有两个数
                //length记下表达式字符串的长度，j记下遍历字符串中数字的个数
                int length = str.length(),j=0;
                //用字符串建立一个动态字符串。
                StringBuffer temp = new StringBuffer(str);
                //开始循环遍历字符串
                for(int i=0; i < length; i++){
                    char cc = temp.charAt(i);//取出下标为i的字符
                    if(first==1&&i==0)        //如果括号括起来的第一个数字为表达式中第一个操作数，在表达式最前面插入(
                        temp.insert(0, '(');
                    if(cc > '9' || cc < '0'){//如果当前字符是运算符字符
                        j++;                //表示刚刚遍历一个数字，所以j加一
                        if(j==first-1){        //如果j到达first的前一个位置，在当前字符的后面插入“(”
                            temp.insert(i+1, '(');i++;
                        }
                        if(j==next)            //如果j到达next的位置，在当前字符前面插入一个“）”
                            temp.insert(i, ')');
                    }
                }
                str = temp.toString();//将动态字符串转换为普通字符串
            }
        }
        //加减有无负数
        /*
        if(!o){

            int length2 = str.length(),j=0,i;
            int m=str.indexOf('-');
            StringBuffer temp = new StringBuffer(str);
            if(m>0){
                for( i=m-1; i>0; i--){
                    char cc = temp.charAt(i);
                    if(cc > '9' || cc < '0')
                        break;
                }
                
                String hh=temp.substring(i+1, m-1);
                int x=Integer.valueOf(hh);
                
                for( i=m; i<length2; i++){
                    char cc = temp.charAt(i);
                    if(cc > '9' || cc < '0')
                        break;
                }
                hh=temp.substring(m+1, i-1);
                int y=Integer.valueOf(hh);
                if(x-y<0){
                    int v=x;
                    x=y;
                    y=v;
                    }
                    
            }
        
        }
        //除法有无余数
        if(!p){
            int length2 = str.length(),j=0,i;
            int m=str.indexOf('/');
            StringBuffer temp = new StringBuffer(str);
            if(m>0){
                for( i=m-1; i>0; i--){
                    char cc = temp.charAt(i);
                    if(cc > '9' || cc < '0')
                        break;
                }
                String hh=temp.substring(i+1, m-1);
                int x=Integer.valueOf(hh);
                for( i=m; i<length2; i++){
                    char cc = temp.charAt(i);
                    if(cc > '9' || cc < '0')
                        break;
                }
                hh=temp.substring(m+1, i-1);
                int y=Integer.valueOf(hh);
                if(x%y!=0)
                    birth( fanwei, fuhao, bra,o, p);
                    
            }
        }
        */
        //余数的判断由于存在括号的原因无法使用。
        
        return str;
    }
}

  字符串表达式求值：

import java.util.Collections;
import java.util.Stack;

public class Calculator {
    private Stack<String> postfixStack  = new Stack<String>();//后缀式栈
    private Stack<Character> opStack  = new Stack<Character>();//运算符栈
    private int [] operatPriority  = new int[] {0,3,2,1,-1,1,0,2};//运用运算符ASCII码-40做索引的运算符优先级
    public static void main(String[] args) {
        System.out.println(5+12*(3+5)/7.0);
        Calculator cal  = new Calculator();
        String s = "5+12*(3+5)/7";
        double result  = cal.calculate(s);
        System.out.println(result);
    }

    /**
     * 按照给定的表达式计算
     * @param expression 要计算的表达式例如:5+12*(3+5)/7
     * @return
     */
    public double calculate(String expression) {
        Stack<String> resultStack  = new Stack<String>();
        prepare(expression);
        Collections.reverse(postfixStack);//将后缀式栈反转
        String firstValue  ,secondValue,currentValue;//参与计算的第一个值，第二个值和算术运算符
        while(!postfixStack.isEmpty()) {
            currentValue  = postfixStack.pop();
            if(!isOperator(currentValue.charAt(0))) {//如果不是运算符则存入操作数栈中
                resultStack.push(currentValue);
            } else {//如果是运算符则从操作数栈中取两个值和该数值一起参与运算
                 secondValue  = resultStack.pop();
                 firstValue  = resultStack.pop();
                 String tempResult  = calculate(firstValue, secondValue, currentValue.charAt(0));
                 resultStack.push(tempResult);
            }
        }
        return Double.valueOf(resultStack.pop());
    }
    
    /**
     * 数据准备阶段将表达式转换成为后缀式栈
     * @param expression
     */
    private void prepare(String expression) {
        opStack.push(',');//运算符放入栈底元素逗号，此符号优先级最低
        char[] arr  = expression.toCharArray();
        int currentIndex  = 0;//当前字符的位置
        int count = 0;//上次算术运算符到本次算术运算符的字符的长度便于或者之间的数值
        char currentOp  ,peekOp;//当前操作符和栈顶操作符
        for(int i=0;i<arr.length;i++) {
            currentOp = arr[i];
            if(isOperator(currentOp)) {//如果当前字符是运算符
                if(count > 0) {
                    postfixStack.push(new String(arr,currentIndex,count));//取两个运算符之间的数字
                }
                peekOp = opStack.peek();
                if(currentOp == ')') {//遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
                    while(opStack.peek() != '(') {
                        postfixStack.push(String.valueOf(opStack.pop()));
                    }
                    opStack.pop();
                } else {
                    while(currentOp != '(' && peekOp != ',' && compare(currentOp,peekOp) ) {
                        postfixStack.push(String.valueOf(opStack.pop()));
                        peekOp = opStack.peek();
                    }
                    opStack.push(currentOp);
                }
                count = 0;
                currentIndex = i+1;
            } else {
                count++;
            }
        }
        if(count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {//最后一个字符不是括号或者其他运算符的则加入后缀式栈中
            postfixStack.push(new String(arr,currentIndex,count));
        } 
        
        while(opStack.peek() != ',') {
            postfixStack.push(String.valueOf( opStack.pop()));//将操作符栈中的剩余的元素添加到后缀式栈中
        }
    }
    
    /**
     * 判断是否为算术符号
     * @param c
     * @return
     */
    private boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' ||c == ')';
    }
    
    /**
     * 利用ASCII码-40做下标去算术符号优先级
     * @param cur
     * @param peek
     * @return
     */
    public  boolean compare(char cur,char peek) {// 如果是peek优先级高于cur，返回true，默认都是peek优先级要低
        boolean result  = false;
        if(operatPriority[(peek)-40] >= operatPriority[(cur) - 40]) {
           result = true;
        }
        return result;
    }
    
    /**
     * 按照给定的算术运算符做计算
     * @param firstValue
     * @param secondValue
     * @param currentOp
     * @return
     */
    private String calculate(String firstValue,String secondValue,char currentOp) {
        String result  = "";
        switch(currentOp) {
            case '+':
                result = String.valueOf(ArithHelper.add(firstValue, secondValue));
                break;
            case '-':
                result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
                break;
            case '*':
                result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
                break;
            case '/':
                result = String.valueOf(ArithHelper.div(firstValue, secondValue));
                break;
        }
        return result;
    }
}

  运行结果截图分析：

   周活动总结表

时间记录日志

  缺陷记录日志