利用栈计算表达式应用——给小朋友出题并计算正答率（并保存数据）

（一）效果展示

题库XX.txt

答题过程

存储记录文件 xx.txt

(二)将所需要用到的+，-，等符号封装，然后写几个判断方法

 public char[] op = {'+','-','*','/','(',')'};  
        public String[] strOp = {"+","-","*","/","(",")"};  
        public boolean isDigit(char c){  
            if(c>='0'&&c<='9'){  
                return true;  
            }  
            return false;  
        }  
        public boolean isOp(char c){  
            for(int i=0;i<op.length;i++){  
                if(op[i]==c){  
                    return true;  
                }  
            }  
            return false;  
        }  
        public boolean isOp(String s){  
            for(int i=0;i<strOp.length;i++){  
                if(strOp[i].equals(s)){  
                    return true;  
                }  
            }  
            return false;  
        }  

（三）因为要将题目都转化成String类型进行处理，所以要处理计算式

  public List<String> work(String str){  
            List<String> list = new ArrayList<String>();  
            char c;  
            
            //StringBuilder 与StringBuffer本质上没什么区别,主要是StringBuilder去掉了保护线程安全那部分的开销 
            //append（）方法用于字符的拼接
            StringBuilder sb = new StringBuilder();  
            for(int i=0;i<str.length();i++){  
                c = str.charAt(i);  
                if(isDigit(c)){  
                    sb.append(c);  
                               }  
                if(isOp(c)){  
                    if(sb.toString().length()>0){  
                        list.add(sb.toString());  
                        sb.delete(0, sb.toString().length());  
                    }  
                    //c+""为的是符合list<String>的存储参数String类型
                    list.add(c+"");  
                }  
            }  
            //将最后sb中的 数据存到List中并且 清空sb
            if(sb.toString().length()>0){  
                list.add(sb.toString());  
                sb.delete(0, sb.toString().length());  
            }  
            return list;  
        }  
        public void printList(List<String> list){  
            for(String o:list){  
                System.out.print(o+" ");  
            }  
        }  

（四）将中缀表达式转化为后缀表达式，然后利用栈进行计算

    public List<String> InfixToPostfix(List<String> list){  
            List<String> Postfixlist = new ArrayList<String>();//存放后缀表达式  
            Stack<String> stack = new Stack<String>();//暂存操作符  
            
            for(int i=0;i<list.size();i++){  
                
                
                  //按优先级压栈 
                String s = list.get(i);  
                if(s.equals("(")){  
                    stack.push(s);  
                }else if(s.equals("*")||s.equals("/")){  
                    stack.push(s);  
                }else if(s.equals("+")||s.equals("-")){  
                    if(!stack.empty()){  
                        while(!(stack.peek().equals("("))){  
                            Postfixlist.add(stack.pop());  
                            if(stack.empty()){  
                                break;  
                            }  
                        }  
                        stack.push(s);  
                    }else{  
                        stack.push(s);  
                    }  
                }else if(s.equals(")")){  
                    while(!(stack.peek().equals("("))){  
                        Postfixlist.add(stack.pop());  
                    }  
                    stack.pop();  
                }else{  
                    Postfixlist.add(s);  
                }  
                if(i==list.size()-1){  
                    while(!stack.empty()){  
                        Postfixlist.add(stack.pop());  
                    }  
                }  
            }  
            return Postfixlist;  
        }  
        /** 
         * 后缀表达式计算 
         */  
        public int doCal(List<String> list){  
            Stack<Integer> stack = new Stack<Integer>();  
            for(int i=0;i<list.size();i++){  
                String s = list.get(i);  
                int t=0;  
                if(!isOp(s)){  
                    t = Integer.parseInt(s);  
                    stack.push(t);  
                }else{  
                    if(s.equals("+")){  
                        int a1 = stack.pop();  
                        int a2 = stack.pop();  
                        int v = a2+a1;  
                        stack.push(v);  
                    }else if(s.equals("-")){  
                        int a1 = stack.pop();  
                        int a2 = stack.pop();  
                        int v = a2-a1;  
                        stack.push(v);  
                    }else if(s.equals("*")){  
                        int a1 = stack.pop();  
                        int a2 = stack.pop();  
                        int v = a2*a1;  
                        stack.push(v);  
                    }else if(s.equals("/")){  
                        int a1 = stack.pop();  
                        int a2 = stack.pop();  
                        int v = a2/a1;  
                        stack.push(v);  
                    }  
                }  
            }  
            return stack.pop();  
        }  

（五）读取文件内容的方法

    public String[] getFile(String pathName) throws Exception {
            // 【1】先创建一个File的实体对象
            File file = new File(pathName);
            
            if (!file.exists())
                throw new RuntimeException("找不到文件!");
            // 【2】加载BUfferedReader流
            BufferedReader br = new BufferedReader(new FileReader(file));
            String str;
            String []arr = null;
            // 【3】一行一行读取
            while ((str = br.readLine()) != null) {

                
                // 文件中数据的分割我用的是‘，’具体根据自己的情况调用下面的split（）函数
                 arr = str.split(",");

            }
            return arr;
        }

（六）将记录存储到文件中的方法

        // 将数据存储到文件中
        public  void toFile(String path,int sumOfQ,String []wqs,int []Wresult,String TL,int []result,int[]arr) throws Exception {
            File file = null;
            FileWriter fWriter = null;
            file = new File(path);
            try {
                if (!file.exists()) {
                    System.out.println("要读入数据的文件不存在");
                }
                fWriter = new FileWriter(file);
                fWriter.write("答题的数量："+sumOfQ+"
");
                fWriter.write("相应题目:
");
                for (int i = 0; i < sumOfQ; i++) {
                    fWriter.write(wqs[arr[i]]+"
");
                }
                
                fWriter.write("你当时的提交答案:  ");
                for (int i = 0; i < Wresult.length; i++) {
                    fWriter.write(Wresult[i]+" ");
                }
                fWriter.write("
");
                
                fWriter.write("本次答题的正答率: "+TL+"
");
                fWriter.write("本次题目的标准答案: ");
                for (int i = 0; i < result.length; i++) {
                    fWriter.write(result[i]+" ");
                }
                fWriter.write("
");
                fWriter.flush();

            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            } finally {
                if (fWriter != null) {
                    fWriter.close();
                }
            }

        }

（七）将标准答案与用户输入答案进行对比，并计算出正答率的方法

        // 用来对比用户的答案和标准答案之间的方法
                    //参数为用户输入的答案数组
    public String compare(int[] a,int[] results,int sumOfQ) {
                        double t = 0;
                         //将答错的题的序号保存到list中方便调用
                        List<Integer> falseQ = new ArrayList<Integer>();
                        for (int i = 0; i < results.length; i++) {
                            if (a[i] == results[i])
                                t++;
                            else {

                                falseQ.add(Integer.valueOf(i + 1));
                            }
                        }

                        if (falseQ.isEmpty()) {
                            System.out.println("恭喜你，答对了所有题目！");
                        } else {
                            System.out.print("答题完成，存在问题的序号为：");
                            for (int i = 0; i < falseQ.size(); i++) {
                                System.out.print(falseQ.get(i) + " ");
                            }
                        }
                        System.out.println();
                        System.out.println("你的正答率为：" + (DF_00(Double.valueOf(t / sumOfQ * 100))) + "%");

                        return String.valueOf(DF_00(Double.valueOf(t / sumOfQ * 100)))+"%";
                    }

（八）对各种数据和运算结果进行规范的方法

        public static double DF_00(Double b) {
            //调用DecimalForamt类的实例对象 对数据进行位数规范，
            //因为规范完后的数据我还要进行操作，我又将它进行强制转化
        DecimalFormat dFormat = new DecimalFormat("#.00");
        return        Double.parseDouble(dFormat.format(b));
                    }    

（九）用来随机出题的方法

                    public int[] suiji(int sumOfQ,String[]wqs) {

                        int[] arr = new int[sumOfQ];
                        arr[0] = (int) (Math.floor(Math.random() * (wqs.length)));
                        boolean isSame = true;
                           int j=0;
                        while (isSame == true) {

                            int suiji = (int) (Math.floor(Math.random() * (wqs.length)));
                            for (int i = 0; i < arr.length; i++) {
                                if (arr[i] == suiji) {
                                    isSame = true;
                                    break;
                                } else {
                                    isSame = false;
                                    continue;
                                }

                            }
                            if (!isSame) {

                                arr[j] = suiji;
                                j++;
                                isSame = true;
                            }

                            if (j == 3) {
                                break;
                            }
                        }
                        return arr;
                    }                    

（十）用来让用户输入答案，并保存答案的方法

                    //用来让用户输入答案，并且保存用户输入的答案
                    public int [] Wresult(int sumOfQ) {
                        System.out.println("请依次输入你的答案：");
                        Scanner sc = new Scanner(System.in);
                        String nextLine = sc.nextLine();

                        String[] temp = nextLine.split(" ");

                        int[] Wresult = new int[sumOfQ];

                        for (int i = 0; i < temp.length; i++) {
                            int wResult = Integer.parseInt(temp[i]);
                            Wresult[i] = wResult;
                        }
                        
                        
                        return Wresult;
                    }

（十一）测试

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        LV lt = new LV();

        // 获取题目内容
        try {
            wqs = lt.getFile("数据结构第二阶段.txt");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("请输入题目数目：");
        Scanner scanner = new Scanner(System.in);
        int sumOfQ = scanner.nextInt();
        
         arrs = lt.suiji(sumOfQ, wqs);
         
         
         
        results = new int[sumOfQ];
        for (int i = 0; i < sumOfQ; i++) {
            String str = wqs[arrs[i]];
            System.out.println((i + 1) + ":      " + str);
            List<String> list = lt.work(str);
            List<String> list2 = lt.InfixToPostfix(list);
            results[i] = lt.doCal(list2);
        }

        
        
        int[] Wresult = lt.Wresult(sumOfQ);

        
        String TL = lt.compare(results, Wresult, sumOfQ);
        
        
        System.out.println("正确答案为：");
        for (int i = 0; i < results.length; i++) {
            System.out.println((i + 1) + ":  " + results[i]);
        }
          
    
        System.out.println("本次答题记录正在为您存储请稍后。。。。。");
        Thread thread = new Thread();
        
        try {
            lt.toFile("inputFile.txt", sumOfQ, wqs, Wresult, TL, results,arrs);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        
        try {
            Thread.sleep(1000);
            thread.start();
            System.out.println("记录已存储至inputFile.txt!");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        

    }