随机生成四则运算03

由于工程量巨大，暂先发布一个低版本的。

package MathTest3;

import java.util.Scanner;
import java.math.*;
public class ComMath {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Expresion p = new Expresion();
        //p.SetValue();
        //p.getExpStr();
        p.showExpStr();
        //StackClass.EvaluateExpression(p.get_expStr());//#################
    }

}

class Expresion
{
    private StringBuffer expStr;
    int length;
    private int mulAndDiv;//记录是否有乘除法的状态值      0代表无1代表有
    private int numLowBound;//记录数值下限
    private int numHighBound;//记录数值上限
    private int neviNum;//记录加减是否有负数           0代表无1代表有
    private int remainder;//记录除法是否有余数       0代表无1代表有
    
    public Expresion()
    {
        expStr = new StringBuffer("");
        length = expStr.length();
        mulAndDiv = 1;
        numLowBound = 1;
        numHighBound = 99;
        neviNum = 1;
        remainder = 0;
    }
    
    public String get_expStr()
    {
        return expStr.toString();
    }
    
    //设置是否有乘除法
    public void set_mulAndDiv(int n)
    {
        mulAndDiv = n%2;
    }
        
    //设置是否有负数
    public void set_neviNum(int n)
    {
        neviNum = n%2;
    }
        
    //设置是否有余数
    public void set_remainder(int n)
    {
        remainder = n%2;
    }
        
    //设置计算下限
    public void set_numLowBound(int n)
    {
        if(n < 0)
        {
            System.out.println("您设置的计算下限为负值!系统自动将其恢复为1");
            numLowBound = 1;
        }
        else
        {    
            numLowBound = n;
        }
    }
    
    //设置计算上限
    public void set_numHighBound(int n)
    {
        if(n < 0)
        {
            System.out.println("您设置的计算上限为负值!系统自动将其恢复为100");
            numHighBound = 99;
        }
        else
        {    
            numHighBound = n;
        }
    }
        
    
    //用户设置出题形式
    public void SetValue()
    {
        int mulAndDivValue;//记录是否有乘除法的状态值      0代表无1代表有
        int numLowBoundValue;//记录数值下限
        int numHighBoundValue;//记录数值上限
        int neviNumValue;//记录加减是否有负数           0代表无1代表有
        int remainderValue;//记录除法是否有余数       0代表无1代表有
        System.out.println("hello word!");
            
            
        Scanner sc = new Scanner(System.in);
        System.out.println("请您指定题目中数值的下限:(限制范围在1到100之间)");
        numLowBoundValue = sc.nextInt();
        set_numLowBound(numLowBoundValue);
            
        System.out.println("请您指定题目中数值的上限:(限制范围在1到100之间)");
        numHighBoundValue = sc.nextInt();
        set_numHighBound(numHighBoundValue);
            
        System.out.println("请您指定题目中是否有乘除法(0代表没有1代表有)");
        mulAndDivValue = sc.nextInt();
        set_mulAndDiv(mulAndDivValue);
            
        System.out.println("请您指定题目中减法的结果是否有负数(0代表没有1代表有)");
        neviNumValue = sc.nextInt();
        set_neviNum(neviNumValue);
            
        if(mulAndDivValue == 1)
        {
            System.out.println("请您指定题目中的除法结果是否有余数(0代表没有1代表有)");
            remainderValue = sc.nextInt();
            set_remainder(remainderValue);
        }
            
    }
        
    //返回一个运算符
    public char getOpera()
    {
        int charNum = (int)((Math.random())*4)+1;
        //没有乘除法
        if(mulAndDiv == 0 &&charNum == 3)
        {
                charNum = 1;
        }
        if(mulAndDiv == 0 &&charNum == 4)
        {
                charNum = 2;
        }
        char opera = '+';
        if(charNum == 1)
            opera = '+';
        if(charNum == 2)
            opera = '-';
        if(charNum == 3)
            opera = '*';
        if(charNum == 4)
            opera = '/';
        return opera;
    }
        
    //返回一个运算数
    public int getNum()
    {
        int num = (int)((Math.random())*numHighBound)+numLowBound;
        return num;
    }
        
    //保证减法没有负数
    public void checkNegative()
    {
        for(int i = 1;i < expStr.length();i = i+2)
        {
            if(expStr.charAt(i) == '-')
            {
                if(Integer.parseInt(String.valueOf(expStr.charAt(i-1))) <
                Integer.parseInt(String.valueOf(expStr.charAt(i+1))))
                {
                    char a = expStr.charAt(i-1);
                    char b = expStr.charAt(i+1);
                    expStr.replace(i-1, i, String.valueOf(b));
                    expStr.replace(i+1, i+2, String.valueOf(a));
                }
            }
        }
    }
        
    //保证除法
    public void checkRemainder()
    {
        for(int i = 1;i < expStr.length();i = i+2)
        {
            if(expStr.charAt(i) == '/')
            {
                if(Integer.parseInt(String.valueOf(expStr.charAt(i-1))) <
                Integer.parseInt(String.valueOf(expStr.charAt(i+1))))
                {
                    char a = expStr.charAt(i-1);
                    char b = expStr.charAt(i+1);
                    expStr.replace(i-1, i, String.valueOf(b));
                    expStr.replace(i+1, i+2, String.valueOf(a));
                }    
            }
                
            //没有余数
            if(remainder == 0)
            {
                int left = Integer.parseInt(String.valueOf(expStr.charAt(i-1)));
                int right = Integer.parseInt(String.valueOf(expStr.charAt(i+1)));
                left = left/right * right;
                expStr.replace(i-1, i,String.valueOf(left));
            }
        }
    }
        
        //获得前一个运算符的位置
        public int getPriorChar(int index)
        {
            //默认前面没有运算符
            int loc = -1 ;
            char c;
            for(int i = index - 1;i > 0;i--)
            {
                c = expStr.charAt(i);
                if(c == '+'|| c == '-'|| c == '*'|| c == '/')                          
                {
                    loc = i;
                    break;
                }
            }
            return loc;
        }
                
        //获得下一个运算符的位置
        public int getNextChar(int index)
        {
            //默认后面没有运算符
            int loc = -1 ;
            char c;
            for(int i = index + 1;i <length;i++)
            {
                c = expStr.charAt(i);
                if(c == '+'|| c == '-'|| c == '*'|| c == '/')
                {
                    loc = i;
                    break;
                }
            }
            return loc;
        }
        
        
        
        //为表达式添加括号
        public void addBracket()                                           
        {
            //为减法添加括号
            for(int i = 1;i < expStr.length();i++)
            {
                if(expStr.charAt(i) == '-')
                {
                    if(getPriorChar(i) == -1)
                    {
                        expStr.insert(0, '(');
                        i++;
                        System.out.println("第一个if一个分支"+getPriorChar(i));
                        System.out.println("长度:"+expStr.length());
                    }
                    else
                    {
                        expStr.insert(getPriorChar(i)+1,'(');
                        i++;
                        System.out.println("第一个if二个分支"+getPriorChar(i));
                        System.out.println("长度:"+expStr.length());
                    }
                    
                    if(getNextChar(i) == -1)
                    {
                        expStr.append(')');
                        System.out.println("第二个if一个分支"+getNextChar(i));
                        System.out.println("长度:"+expStr.length());
                    }
                    else
                    {
                        expStr.insert(getNextChar(i), ')');
                        System.out.println("第二个if二个分支"+getNextChar(i));
                        System.out.println("长度:"+expStr.length());
                    }
                }
            }
        }
                
        //获取最后一个运算符
        public char getLastChar()
        {
            char c = '-';
            for(int i = expStr.length()-1;i > 0;i--)
            {
                c = expStr.charAt(i);
                if(c == '+'|| c == '-'|| c == '*'|| c == '/')
                {
                    break;
                }
            }
            return c;
        }
        
        
        
        
        //生成表达式
        public void getExpStr()
        {
            //生成表达式中数字的个数 2-10
            int length = (int)((Math.random())*8)+2;
            int i = 0;
            
            //获得一个初步的表达式
            while(i < length-1)
            {
                String a  =String.valueOf(getNum());
                expStr = expStr.append(a);
                char ch = getOpera();
                //连着的两个运算符不会相同
                char lastChar = getLastChar();
                while(ch == lastChar)
                {
                    ch = getOpera();
                }
                expStr = expStr.append(String.valueOf(ch));
                i++;
            }
            expStr = expStr.append(String.valueOf(getNum()));
            
            //没有负数
//            if(neviNum == 0)
//            {
//                checkNegative();
//            }
//            if(mulAndDiv == 1)
//            {
//                checkRemainder();
//            }
            length = expStr.length();
        }
        
        public void showExpStr()
        {
            getExpStr();
            //addBracket();
            System.out.println(expStr);
            addBracket();
            System.out.println(expStr);
        }
}