题库题型，难易度

sexam/src/main/java/com/xhkjedu/sexam/service/report/EReportGenerateQuestionService.java

     private ERStudentComplexityMapper erStudentComplexityMapper;
 
     public void setClassQuestion(Integer examid, List<Map> subjects, List<Map> classes, EBase base){
-        Integer stuzero  = base.getStuzero();//0分学生是否参与统计0不统计1统计(默认)
+        Integer stuzero = base.getStuzero();//0分学生是否参与统计0不统计1统计(默认)
         // 考试所有学生提交试卷作答情况 2023-12-27添加0分学生是否参与统计
         List<EPaperStudentQuestion> stulist = ePaperStudentQuestionMapper.listExamStudentsAnswer(examid);
         if (N_Utils.isListNotEmpty(stulist)) {
                         // 处理题型下试题：题库显示题号时为母题的题号即order（qn是英语为顺延题号其他学科为母题号和子题排序拼接）
                         String qtypejson = panalyze.get("qnumjson").toString();// 原试卷题型分析
                         List<Map> qtypelist = JSON.parseArray(qtypejson, Map.class);
-                        setPaperQuestionTkQtypes(qtypelist, paperstulist, rtypelist, rqueslist, stutypelist, examPaperClassVo);
+                        setPaperQuestionTkQtypes(qtypelist, paperstulist, rtypelist, rqueslist, stutypelist, examPaperClassVo, stuzero);
 
                         // 处理知识点
-                        setEPaperQuestionPoints(panalyze, paperstulist, rpointlist, stupointlist, examPaperClassVo);
+                        setEPaperQuestionPoints(panalyze, paperstulist, rpointlist, stupointlist, examPaperClassVo, stuzero);
 
                         // 处理难易度
                         String complexityjson = panalyze.get("complexityjson").toString();
                         List<Map> complexitylist = JSON.parseArray(complexityjson, Map.class);
-                        setEPaperQuestionComplexitys(complexitylist, paperstulist, complist, stucomplist, examPaperClassVo);
+                        setEPaperQuestionComplexitys(complexitylist, paperstulist, complist, stucomplist, examPaperClassVo, stuzero);
 
                     } else {
                         // 处理题型及题型下试题：附件显示题号为qn（order）作为排序使用
                     } else {
                         ercq.setErroroption("");
                     }
-                    
+
                     rqueslist.add(ercq);// 单个试题统计
 
                     if (tclassmap.containsKey(classid)) {
             }
 
             Double tgavgscore = 0D;
+            Double tgsrate = 0D;
             if(gstunum >0){
                 tgavgscore = N_Utils.getDoubleDivideForAvg(tgstuscore, gstunum);// 题型下年级平均分
+                tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
             }
 
-            Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
             // 题型--班级得分
             for (Map.Entry<Integer, ERClassScoreVo> entry : tclassmap.entrySet()) {
                 ERClassScoreVo erClassScoreVo = entry.getValue();
 
     // 题型、试题、知识点、难易度--题库题型
     private void setPaperQuestionTkQtypes(List<Map> qtypelist, List<EPaperStudentQuestion> paperstulist, List<ERclassQtype> rtypelist, List<ERclassQuestion> rqueslist,
-                                          List<ERStudentQtype> stutypelist, ExamPaperClassVo examPaperClassVo) {
+                                          List<ERStudentQtype> stutypelist, ExamPaperClassVo examPaperClassVo,Integer stuzero) {
         List<Map> classes = examPaperClassVo.getClasses();
         for (int k = 0; k < qtypelist.size(); k++) {
             Map qtypemap = qtypelist.get(k);
                 qns = qns + order + ",";
 
                 // 获取集合中对应子题集合的数据
-                List<EPaperStudentQuestion> qgstulist = null;
+                List<EPaperStudentQuestion> qgstulistZero = null;
                 Integer eptqid = null;
                 if (qlevel == 1) {
                     // 单题时直接为试题id
                     eptqid = eptqids.get(0);
                     Integer teptqid = eptqid;
-                    qgstulist = paperstulist.stream().filter(s -> teptqid.equals(s.getEptqid())).collect(Collectors.toList());
+                    qgstulistZero = paperstulist.stream().filter(s -> teptqid.equals(s.getEptqid())).collect(Collectors.toList());
                 } else {
-                    qgstulist = new ArrayList<>();
+                    qgstulistZero = new ArrayList<>();
                     List<EPaperStudentQuestion> stuqlist = paperstulist.stream().filter(s -> eptqids.contains(s.getEptqid())).collect(Collectors.toList());
                     // 母子题情况，计算所有子题的和即为母题。把试题按照学生分组，分组为一组的即为
                     Map<Integer, List<EPaperStudentQuestion>> stuQuesMap = stuqlist.stream().collect(Collectors.groupingBy(EPaperStudentQuestion::getStudentid));
                         List<EPaperStudentQuestion> stuqueslist = entry.getValue();
                         EPaperStudentQuestion pfist = stuqueslist.get(0);
                         EPaperStudentQuestion pstq = new EPaperStudentQuestion();
+                        pstq.setStupaperscore(pfist.getStupaperscore());
                         pstq.setClassid(pfist.getClassid());
                         pstq.setStudentid(entry.getKey());
 
                         if (good > 0) {
                             pstq.setGood(1);
                         }
-                        qgstulist.add(pstq);
+                        qgstulistZero.add(pstq);
                     }
                 }
 
+                EPaperStudentQuestion ePaperStudentQuestion = qgstulistZero.get(0);
+                List<EPaperStudentQuestion> qgstulist = new ArrayList<>();
+                if(stuzero == 0){//如果为0：0分学生不参与统计
+                    qgstulist = qgstulistZero.stream().filter(s -> s.getStupaperscore() > 0).collect(Collectors.toList());
+                }else{
+                    //1:0分学生参与统计
+                    qgstulist.addAll(qgstulistZero);
+                }
+
                 gstunum = qgstulist.size();
-                Double qgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
-                qgscore = N_Utils.formatDouble(qgscore, 1);
-                Double qgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                qgstuscore = N_Utils.formatDouble(qgstuscore, 1);
-                EPaperStudentQuestion qgmaxscore = qgstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
-                tgscore = ExamUtil.add(tgscore, qgscore);
-                tgstuscore = ExamUtil.add(tgstuscore, qgstuscore);
+                Double qgscore = 0D;
+                Double qgstuscore = 0D;
+                EPaperStudentQuestion qgmaxscore = null;
+                Double qgavgscore = 0D;
+                Double qgsrate = 0D;
+                if(gstunum > 0){
+                    qgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                    qgscore = N_Utils.formatDouble(qgscore, 1);
+                    qgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                    qgstuscore = N_Utils.formatDouble(qgstuscore, 1);
+                    qgmaxscore = qgstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
+                    tgscore = ExamUtil.add(tgscore, qgscore);
+                    tgstuscore = ExamUtil.add(tgstuscore, qgstuscore);
+                    qgavgscore= N_Utils.getDoubleDivideForAvg(qgstuscore, gstunum);
+                    qgsrate = N_Utils.getDoubleDivideAndMulitiply(qgstuscore, qgscore);
+                }
 
                 for (Map classm : classes) {
                     Integer classid = Integer.parseInt(classm.get("classid").toString());
                     List<EPaperStudentQuestion> qcstulist = qgstulist.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
-                    if (N_Utils.isListNotEmpty(qcstulist)) {
-                        int cstunum = qcstulist.size();// 班级下试题作答学生数量
-                        Double qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                    List<EPaperStudentQuestion> qcstulistZero = qgstulistZero.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
+
+                    int cstunum = qcstulist.size();// 班级下试题作答学生数量
+                    Double qcscore = 0D;
+                    Double qcstuscore = 0D;
+                    Double qcavgscore = 0D;
+                    EPaperStudentQuestion maxscore = null;
+                    Double qcsrate = 0D;
+                    if(cstunum > 0){
+                        qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
                         qcscore = N_Utils.formatDouble(qcscore, 1);
-                        Double qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                        qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
                         qcstuscore = N_Utils.formatDouble(qcstuscore, 1);
-                        Double qcavgscore = N_Utils.getDoubleDivideForAvg(qcstuscore, cstunum);
-                        EPaperStudentQuestion maxscore = qcstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
+                        qcavgscore = N_Utils.getDoubleDivideForAvg(qcstuscore, cstunum);
+                        maxscore = qcstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
+                        qcsrate = N_Utils.getDoubleDivideAndMulitiply(qcstuscore, qcscore);
+                    }
 
-                        if (tclassmap.containsKey(classid)) {
-                            ERClassScoreVo erClassScoreVo = tclassmap.get(classid);
-                            erClassScoreVo.setStuscore(ExamUtil.add(erClassScoreVo.getStuscore(), qcstuscore));
-                            erClassScoreVo.setCscore(ExamUtil.add(erClassScoreVo.getCscore(), qcscore));
+                    if (tclassmap.containsKey(classid)) {
+                        ERClassScoreVo erClassScoreVo = tclassmap.get(classid);
+                        erClassScoreVo.setStuscore(ExamUtil.add(erClassScoreVo.getStuscore(), qcstuscore));
+                        erClassScoreVo.setCscore(ExamUtil.add(erClassScoreVo.getCscore(), qcscore));
+                    } else {
+                        ERClassScoreVo erClassScoreVo = new ERClassScoreVo();
+                        erClassScoreVo.setStunum(cstunum);
+                        erClassScoreVo.setStuscore(qcstuscore);
+                        erClassScoreVo.setCscore(qcscore);
+                        tclassmap.put(classid, erClassScoreVo);
+                    }
+                    for (EPaperStudentQuestion psq : qcstulistZero) {
+                        if (tstumap.containsKey(psq.getStudentid())) {
+                            ERStudentQtype sq = tstumap.get(psq.getStudentid());
+                            sq.setStuscore(ExamUtil.add(sq.getStuscore(), psq.getStuscore()));
                         } else {
-                            ERClassScoreVo erClassScoreVo = new ERClassScoreVo();
-                            erClassScoreVo.setStunum(cstunum);
-                            erClassScoreVo.setStuscore(qcstuscore);
-                            erClassScoreVo.setCscore(qcscore);
-                            tclassmap.put(classid, erClassScoreVo);
-                        }
-                        for (EPaperStudentQuestion psq : qcstulist) {
-                            if (tstumap.containsKey(psq.getStudentid())) {
-                                ERStudentQtype sq = tstumap.get(psq.getStudentid());
-                                sq.setStuscore(ExamUtil.add(sq.getStuscore(), psq.getStuscore()));
-                            } else {
-                                ERStudentQtype sq = new ERStudentQtype();
-                                sq.setClassid(psq.getClassid());
-                                sq.setStudentid(psq.getStudentid());
-                                sq.setStuscore(psq.getStuscore());
-                                tstumap.put(psq.getStudentid(), sq);
-                            }
+                            ERStudentQtype sq = new ERStudentQtype();
+                            sq.setClassid(psq.getClassid());
+                            sq.setStudentid(psq.getStudentid());
+                            sq.setStuscore(psq.getStuscore());
+                            tstumap.put(psq.getStudentid(), sq);
                         }
+                    }
 
-                        // 班级单题情况
-                        ERclassQuestion ercq = new ERclassQuestion();
-                        ercq.setCtype(qcstulist.get(0).getCtype());
-                        ercq.setExamid(examPaperClassVo.getExamid());
-                        ercq.setClassid(classid);
-                        ercq.setSubjectid(examPaperClassVo.getSubjectid());
-                        ercq.setEpid(examPaperClassVo.getEpid());
-                        ercq.setEptqid(eptqid);
-                        ercq.setQuestionid(questionid);
-                        ercq.setQtypename(quesname);
-                        ercq.setComplexity(complexity);
-                        ercq.setScore(quesscore);
-                        ercq.setQn(String.join(",", qnslist));
-                        ercq.setQorder(Integer.parseInt(order));
-                        ercq.setClassscore(qcstuscore);
+                    // 班级单题情况
+                    ERclassQuestion ercq = new ERclassQuestion();
+                    ercq.setCtype(ePaperStudentQuestion.getCtype());
+                    ercq.setExamid(examPaperClassVo.getExamid());
+                    ercq.setClassid(classid);
+                    ercq.setSubjectid(examPaperClassVo.getSubjectid());
+                    ercq.setEpid(examPaperClassVo.getEpid());
+                    ercq.setEptqid(eptqid);
+                    ercq.setQuestionid(questionid);
+                    ercq.setQtypename(quesname);
+                    ercq.setComplexity(complexity);
+                    ercq.setScore(quesscore);
+                    ercq.setQn(String.join(",", qnslist));
+                    ercq.setQorder(Integer.parseInt(order));
+                    ercq.setClassscore(qcstuscore);
+                    if(maxscore == null){
+                        ercq.setClassmaxscore(0D);
+                    }else {
                         ercq.setClassmaxscore(maxscore.getStuscore());
-                        ercq.setClassavgscore(qcavgscore);
-                        Double qcsrate = N_Utils.getDoubleDivideAndMulitiply(qcstuscore, qcscore);
-                        ercq.setClasssrate(qcsrate);
-                        ercq.setClassratetype(ExamUtil.getScoreRateType(qcsrate));
+                    }
+                    ercq.setClassavgscore(qcavgscore);
+                    ercq.setClasssrate(qcsrate);
+                    ercq.setClassratetype(ExamUtil.getScoreRateType(qcsrate));
+                    if(qgmaxscore == null){
+                        ercq.setGrademaxscore(0D);
+                    }else {
                         ercq.setGrademaxscore(qgmaxscore.getStuscore());
-                        ercq.setGradescore(qgstuscore);
-                        ercq.setGradeavgscore(N_Utils.getDoubleDivideForAvg(qgstuscore, gstunum));
-                        ercq.setGradesrate(N_Utils.getDoubleDivideAndMulitiply(qgstuscore, qgscore));
-                        // 处理单选题选项情况
-                        Map stuansmap = setPaperQuestionsForStuAnswer(qcstulist);
-                        ercq.setFullscorenum(N_Utils.str2Int(stuansmap.get("fullscorenum").toString()));
-                        ercq.setAnswerjson(stuansmap.get("answerlist").toString());
-                        if (N_Utils.isNotEmpty(stuansmap.get("goodlist"))) {
-                            ercq.setGoodstujson(stuansmap.get("goodlist").toString());
-                        }
-                        if (N_Utils.isNotEmpty(stuansmap.get("badlist"))) {
-                            ercq.setBadstujson(stuansmap.get("badlist").toString());
-                        }
-                        if (N_Utils.isNotEmpty(stuansmap.get("erroroption"))) {
-                            ercq.setErroroption(stuansmap.get("erroroption").toString());
-                        } else {
-                            ercq.setErroroption("");
-                        }
-                        rqueslist.add(ercq);// 单个试题统计
                     }
+                    ercq.setGradescore(qgstuscore);
+                    ercq.setGradeavgscore(qgavgscore);
+                    ercq.setGradesrate(qgsrate);
+                    // 处理单选题选项情况
+                    Map stuansmap = setPaperQuestionsForStuAnswer(qcstulistZero);
+                    ercq.setFullscorenum(N_Utils.str2Int(stuansmap.get("fullscorenum").toString()));
+                    ercq.setAnswerjson(stuansmap.get("answerlist").toString());
+                    if (N_Utils.isNotEmpty(stuansmap.get("goodlist"))) {
+                        ercq.setGoodstujson(stuansmap.get("goodlist").toString());
+                    }
+                    if (N_Utils.isNotEmpty(stuansmap.get("badlist"))) {
+                        ercq.setBadstujson(stuansmap.get("badlist").toString());
+                    }
+                    if (N_Utils.isNotEmpty(stuansmap.get("erroroption"))) {
+                        ercq.setErroroption(stuansmap.get("erroroption").toString());
+                    } else {
+                        ercq.setErroroption("");
+                    }
+                    rqueslist.add(ercq);// 单个试题统计
                 }
             }
-
-            Double tgavgscore = N_Utils.getDoubleDivideForAvg(tgstuscore, gstunum);// 题型下年级平均分
-            Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
+            Double tgavgscore = 0D;
+            Double tgsrate = 0D;
+            if(gstunum > 0){
+                tgavgscore = N_Utils.getDoubleDivideForAvg(tgstuscore, gstunum);// 题型下年级平均分
+                tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
+            }
 
             // 题型--班级得分
             for (Map.Entry<Integer, ERClassScoreVo> entry : tclassmap.entrySet()) {
                 eRclassQtype.setGradeavgscore(tgavgscore);
                 eRclassQtype.setGradesrate(tgsrate);
                 eRclassQtype.setClassscore(erClassScoreVo.getStuscore());
-                eRclassQtype.setClassavgscore(N_Utils.getDoubleDivideForAvg(erClassScoreVo.getStuscore(), erClassScoreVo.getStunum()));
-                eRclassQtype.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getStuscore(), erClassScoreVo.getCscore()));
+                if(erClassScoreVo.getStunum() == 0){
+                    eRclassQtype.setClassavgscore(0D);
+                }else{
+                    eRclassQtype.setClassavgscore(N_Utils.getDoubleDivideForAvg(erClassScoreVo.getStuscore(), erClassScoreVo.getStunum()));
+                }
+                if(erClassScoreVo.getCscore() == 0){
+                    eRclassQtype.setClasssrate(0D);
+                }else{
+                    eRclassQtype.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getStuscore(), erClassScoreVo.getCscore()));
+                }
+
                 eRclassQtype.setQns(qns.substring(0, qns.lastIndexOf(",")));
                 rtypelist.add(eRclassQtype);
             }
 
     // 题型、试题、知识点、难易度--知识点
     private void setEPaperQuestionPoints(Map panalyze, List<EPaperStudentQuestion> paperstulist, List<ERclassPoint> cpointlist, List<ERstudentPoint> stupointlist,
-                                         ExamPaperClassVo examPaperClassVo) {
+                                         ExamPaperClassVo examPaperClassVo,Integer stuzero) {
         // 原试卷知识点分析
         String pointjson = panalyze.get("pointjson").toString();
         List<Map> pointlist = JSON.parseArray(pointjson, Map.class);
             Map pointmap = points.get(0);
             // 说明该试题仅有一个知识点得分直接为改知识点分值
             ERPointStuScoreVo pscvo = new ERPointStuScoreVo();
+            pscvo.setStupaperscore(sq.getStupaperscore());
             pscvo.setClassid(sq.getClassid());
             pscvo.setStudentid(sq.getStudentid());
             pscvo.setStuscore(sq.getStuscore());
             for (int j = 0; j < points.size(); j++) {
                 Map pointmap = points.get(j);
                 ERPointStuScoreVo pscvo = new ERPointStuScoreVo();
+                pscvo.setStupaperscore(sq.getStupaperscore());
                 pscvo.setClassid(sq.getClassid());
                 pscvo.setStudentid(sq.getStudentid());
                 String pointid = pointmap.get("pointid").toString();
 
     // 题型、试题、知识点、难易度--难易度
     private void setEPaperQuestionComplexitys(List<Map> complexitylist, List<EPaperStudentQuestion> paperstulist, List<ERclassComplexity> complist,
-                                              List<ERStudentComplexity> stucomplist, ExamPaperClassVo examPaperClassVo) {
+                                              List<ERStudentComplexity> stucomplist, ExamPaperClassVo examPaperClassVo,Integer stuzero) {
         List<Map> classes = examPaperClassVo.getClasses();
         for (Map compmap : complexitylist) {
             Integer complexity = Integer.parseInt(compmap.get("level").toString());
                 levelstuquelist.addAll(petqqueslit);
             }
 
-            List<EPaperStudentQuestion> qgstulist = new ArrayList<>();// 每个学生难易度下得分
+            List<EPaperStudentQuestion> qgstulistZero = new ArrayList<>();// 每个学生难易度下得分
             Map<Integer, List<EPaperStudentQuestion>> stuQuesMap = levelstuquelist.stream().collect(Collectors.groupingBy(EPaperStudentQuestion::getStudentid));
             for (Map.Entry<Integer, List<EPaperStudentQuestion>> entry : stuQuesMap.entrySet()) {
                 List<EPaperStudentQuestion> stuqueslist = entry.getValue();
+                log.error("key:" + entry.getKey());
                 EPaperStudentQuestion pfirst = stuqueslist.get(0);
                 EPaperStudentQuestion pstq = new EPaperStudentQuestion();
+                pstq.setStupaperscore(pfirst.getStupaperscore());
                 pstq.setStudentid(entry.getKey());
                 pstq.setClassid(pfirst.getClassid());
                 Double qstuscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
                 qscore = N_Utils.formatDouble(qscore, 1);
                 pstq.setQscore(qscore);
                 pstq.setStuscore(qstuscore);
-                qgstulist.add(pstq);
+                qgstulistZero.add(pstq);
 
                 ERStudentComplexity stucomp = new ERStudentComplexity();
                 stucomp.setStudentid(entry.getKey());
                 stucomplist.add(stucomp);
             }
 
-            Double tgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();// 难易度下学生得分
-            tgstuscore = N_Utils.formatDouble(tgstuscore, 1);
-            Double tgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();// 难易度下试题总分
-            tgscore = N_Utils.formatDouble(tgscore, 1);
-            Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
-            Double tgavgscore = N_Utils.getDoubleDivideForAvg(tgstuscore, qgstulist.size());
+            List<EPaperStudentQuestion> qgstulist = new ArrayList<>();
+            if(stuzero == 0){
+                //如果为0：0分学生不参与统计
+                qgstulist = qgstulistZero.stream().filter(s -> s.getStupaperscore() > 0).collect(Collectors.toList());
+            }else{
+                qgstulist.addAll(qgstulistZero);
+            }
 
+            Double tgstuscore = 0D;
+            Double tgscore = 0D;
+            Double tgsrate = 0D;
+            Double tgavgscore = 0D;
+            if(qgstulist.size() > 0){
+                tgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();// 难易度下学生得分
+                tgstuscore = N_Utils.formatDouble(tgstuscore, 1);
+                tgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();// 难易度下试题总分
+                tgscore = N_Utils.formatDouble(tgscore, 1);
+                tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);// 年级得分率
+                tgavgscore = N_Utils.getDoubleDivideForAvg(tgstuscore, qgstulist.size());
+            }
 
             for (Map classm : classes) {
                 Integer classid = Integer.parseInt(classm.get("classid").toString());
                 List<EPaperStudentQuestion> qcstulist = qgstulist.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
-                if (N_Utils.isListNotEmpty(qcstulist)) {
-                    Double qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                // List<EPaperStudentQuestion> qcstulistZero = qgstulistZero.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
+                Double qcscore = 0D;
+                Double qcstuscore = 0D;
+                Double qcavgscore = 0D;
+                Double qcrate = 0D;
+                if (N_Utils.isListNotEmpty(qcstulist) && qcstulist.size() > 0) {
+                    qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
                     qcscore = N_Utils.formatDouble(qcscore, 1);
-                    Double qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                    qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
                     qcstuscore = N_Utils.formatDouble(qcstuscore, 1);
-                    Double qcavgscore = N_Utils.getDoubleDivideForAvg(qcstuscore, qcstulist.size());
-
-                    ERclassComplexity erc = new ERclassComplexity();
-                    erc.setExamid(examPaperClassVo.getExamid());
-                    erc.setSubjectid(examPaperClassVo.getSubjectid());
-                    erc.setEpid(examPaperClassVo.getEpid());
-                    erc.setClassid(classid);
-                    erc.setComplexity(complexity);
-                    erc.setScore(score);
-                    erc.setSrate(srate);
-                    erc.setGradescore(tgstuscore);
-                    erc.setGradeavgscore(tgavgscore);
-                    erc.setGradesrate(tgsrate);
-                    erc.setClassscore(qcstuscore);
-                    erc.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(qcstuscore, qcscore));
-                    erc.setClassavgscore(qcavgscore);
-                    erc.setQns(qns.substring(0, qns.lastIndexOf(",")));
-                    complist.add(erc);
+                    qcavgscore = N_Utils.getDoubleDivideForAvg(qcstuscore, qcstulist.size());
+                    qcrate = N_Utils.getDoubleDivideAndMulitiply(qcstuscore, qcscore);
                 }
+                ERclassComplexity erc = new ERclassComplexity();
+                erc.setExamid(examPaperClassVo.getExamid());
+                erc.setSubjectid(examPaperClassVo.getSubjectid());
+                erc.setEpid(examPaperClassVo.getEpid());
+                erc.setClassid(classid);
+                erc.setComplexity(complexity);
+                erc.setScore(score);
+                erc.setSrate(srate);
+                erc.setGradescore(tgstuscore);
+                erc.setGradeavgscore(tgavgscore);
+                erc.setGradesrate(tgsrate);
+                erc.setClassscore(qcstuscore);
+                erc.setClasssrate(qcrate);
+                erc.setClassavgscore(qcavgscore);
+                erc.setQns(qns.substring(0, qns.lastIndexOf(",")));
+                complist.add(erc);
             }
         }
     }

sexam/src/main/java/com/xhkjedu/sexam/vo/report/ERPointStuScoreVo.java

     private Double stuscore;//学生得分
 
     private String eptqids;//试题id
+
+    private Double stupaperscore;//学生试卷得分
 }