Merge remote-tracking branch 'origin/ywx' into wn

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportclass/MsrClassSubject.java

@@ -9,7 +9,7 @@ import javax.persistence.Table;
 /**
  * @Description 阅卷报告-班级学科分析表
  * @Author auto
- * @Date 2024-12-09
+ * @Date 2024-12-26
  */
 @Data
 @Table(name = "msr_class_subject")
@@ -32,7 +32,7 @@ public class MsrClassSubject extends BaseBean {
     //班级最低分
     private Double classminscore;
     //班级最低分在校排名
-    private String classminrank;
+    private Integer classminrank;
     //班级平均分
     private Double classavgscore;
     //班级平均得分率
@@ -48,9 +48,9 @@ public class MsrClassSubject extends BaseBean {
     //校平均分得分率
     private Double schoolavgrate;
     //全科及格率
-    private Double qkjgrate;
+    private Double qkjgl;
     //综合率
-    private Double zhrate;
+    private Double zhl;
     //标准差
     private Double bzc;
     //标准分
@@ -58,29 +58,29 @@ public class MsrClassSubject extends BaseBean {
     //标准分排名
     private Integer bzfrank;
     //超均率
-    private Double cjlrate;
+    private Double cjl;
     //超均率在校排名
     private Integer cjlrank;
     //比均率
-    private Double bjrate;
+    private Double bjl;
     //比均率在校排名
-    private Integer bjlrate;
+    private Integer bjlrank;
     //中位数
     private Double zws;
     //中位数在校排名
     private Integer zwsrank;
     //离均差
     private Double ljc;
-    //离均率
-    private Double ljl;
-    //离均率在校排名
-    private Integer ljlrank;
+    //离均差在校排名
+    private Integer ljcrank;
     //众数
     private String zs;
+    //众数最大值
+    private Double zsmax;
     //众数在校排名
     private Integer zsrank;
     //均衡率
-    private Double jhrate;
+    private Double jhl;
     //得分贡献指数
     private Double dfgxzs;
     //平均分贡献指数

smarking/src/main/java/com/xhkjedu/smarking/service/report/reportother/MsrExamService.java

@@ -19,6 +19,7 @@ import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectClass;
 import com.xhkjedu.smarking.utils.MarkingUtil;
 import com.xhkjedu.smarking.vo.report.reportclass.ClassTopVo;
+import com.xhkjedu.smarking.vo.report.reportclass.RankRateGroupVo;
 import com.xhkjedu.smarking.vo.report.reportother.*;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
@@ -269,41 +270,59 @@ public class MsrExamService {
         msrStudents.addAll(classSubjectStudents);
         if (N_Utils.isListNotEmpty(msrStudents)) msrStudentMapper.insertList(msrStudents);
 
-        //科目班级分数分布区间分析、班级学科分析
-        //区间参数
+        saveSubjectClass(examid, msrStudents);//科目班级分数分布区间分析
+        saveClassSubject(examid, msrStudents);//班级学科分析
+        saveClassTop(examid, msrStudents);//班级学科前60分析
+
+        saveClassSubjectGrade(examid, "zh", msrStudents);//综合报告-班级学科四率等级分析
+        saveClassSubjectGrade(examid, "xj", msrStudents);//校级报告-班级学科四率等级分析
+        saveClassRankGroup(examid, msrStudents);//学科报告-班级学科名次分组分析
+        saveClassRankRate(examid, msrStudents);//综合报表-名次和比例分析
+        saveClassSection(examid, 1, "zh", msrStudents);//综合报表-分段统计
+        saveClassSection(examid, 2, "zh", msrStudents);//综合报表-累计统计
+        saveClassSection(examid, 1, "xj", msrStudents);//校级报告-分段统计
+        saveClassSection(examid, 1, "xk", msrStudents);//学科报告-分段统计
+        saveClassSection(examid, 1, "bj", msrStudents);//班级报告-分段统计
+        saveClassSection(examid, 1, "jxzl", msrStudents);//教学质量-分段统计
+        saveClassNearLine(examid, msrStudents);//分档上线统计
+        saveClassGoodBad(examid, "all", msrStudents);//重点学生-优劣名次统计
+
+        examMapper.updateExamState(examid, 3);
+    }
+
+    //科目班级分数分布区间分析
+    public void saveSubjectClass(Integer examid, List<MsrStudent> msrStudents) {
         Map<String, SzJsonVo> qjMap = new HashMap<>();
         List<MsrReportparam> params = getMsrReportParams(examid, "scoresection", "xk");
         for (MsrReportparam param : params) {
             qjMap.put(param.getSubjectid(), JSON.parseObject(param.getSzjson(), SzJsonVo.class));
         }
         List<MsrSubjectClass> msrSubjectClasses = new ArrayList<>();//科目班级分数分布区间分析
-        List<MsrClassSubject> msrClassSubjects = new ArrayList<>();//班级学科分析
-        List<MsrClassTop> msrClassTops = new ArrayList<>();//班级学科前60分析
-        Map<String, ClassTopVo> lsMap = new HashMap<>();//处于年级60%得分map
-        for (MsrSubject subject : msrSubjects) {
-            Double lsscore = subject.getLsscore();
-            String subjectid1 = subject.getSubjectid();
-            List<MsrStudent> lsstudents = msrStudents.stream().filter(s -> s.getSubjectid().equals(subjectid1) && s.getStuscore().compareTo(lsscore) >= 0).collect(Collectors.toList());
-            ClassTopVo classTopVo = new ClassTopVo();
-            classTopVo.setSubjectid(subjectid1);
-            classTopVo.setLsscore(lsscore);
-            classTopVo.setXtnum(lsstudents.size());
-            double average = lsstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
-            classTopVo.setXtavgscore(N_Utils.formatDouble(average, 2));
-            String xtstuids = lsstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
-            classTopVo.setXtstuids(xtstuids);
-            lsMap.put(subjectid1, classTopVo);
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, rsMap);
         }
+        setSubjectClass(examid, collect, qjMap, msrSubjectClasses, rsMap);
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setSubjectClass(examid, scCollect, qjMap, msrSubjectClasses, rsMap);
+        msrSubjectClassMapper.insertList(msrSubjectClasses);
+    }
+
+    //科目班级分数分布区间计算
+    private void setSubjectClass(Integer examid, Map<String, List<MsrStudent>> scCollect, Map<String, SzJsonVo> qjMap
+            , List<MsrSubjectClass> msrSubjectClasses, Map<String, Integer> rsMap) {
+        Integer totalnum;
+        String subjectid;
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
             String key = entry.getKey();
             Integer classid = N_Utils.obj2Int(key.split("_")[0]);
             subjectid = key.split("_")[1];
             SzJsonVo vo = qjMap.get(subjectid);
             List<MsrStudent> studentList = entry.getValue();
-            totalnum = studentList.size();//区间总人数
-            Double fullscore1 = studentList.get(0).getFullscore();
-            List<RankGroupVo> fdScore = MarkingUtil.fdScore(fullscore1, N_Utils.obj2Int(vo.getDjvalue()));
+            totalnum = rsMap.get(subjectid);//科目总人数
+            Double fullscore = studentList.get(0).getFullscore();
+            List<RankGroupVo> fdScore = MarkingUtil.fdScore(fullscore, N_Utils.obj2Int(vo.getDjvalue()));
             for (RankGroupVo rg : fdScore) {
                 int minscore = rg.getMinvalue();
                 int maxscore = rg.getMaxvalue();
@@ -311,7 +330,7 @@ public class MsrExamService {
                 double min = MarkingUtil.objToDouble(minscore);
                 double max = MarkingUtil.objToDouble(maxscore);
                 List<MsrStudent> qjstudents;
-                if (fullscore1.compareTo(max) == 0) {
+                if (fullscore.compareTo(max) == 0) {
                     qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0).collect(Collectors.toList());
                 } else {
                     qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0 && s.getStuscore().compareTo(max) < 0).collect(Collectors.toList());
@@ -325,18 +344,189 @@ public class MsrExamService {
                 msrSubjectClass.setQjnum(qjnum);
                 msrSubjectClass.setQjrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
                 double qjavg = qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
-                msrSubjectClass.setQjavgrate(N_Utils.getDoubleDivideAndMulitiply(qjavg, fullscore1));
+                msrSubjectClass.setQjavgrate(N_Utils.getDoubleDivideAndMulitiply(qjavg, fullscore));
                 String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
                 msrSubjectClass.setStuids(stuids);
                 msrSubjectClasses.add(msrSubjectClass);
             }
+        }
+    }
+
+    //班级学科分析
+    public void saveClassSubject(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrClassSubject> msrClassSubjects = new ArrayList<>();//班级学科分析
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, rsMap);
+        }
+        List<MsrReportparam> params = getMsrReportParams(examid, "allrate", "all");
+        SzJsonVo vo = JSON.parseObject(params.get(0).getSzjson(), SzJsonVo.class);
+        String calformula = vo.getCalformula();
+        Map<String, MsrClassSubject> csMap = new HashMap<>();//班级学科map
+        setClassSubject(examid, collect, msrClassSubjects, csMap, calformula);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSubject(examid, scCollect, msrClassSubjects, csMap, calformula);
+
+        Map<String, List<MsrClassSubject>> scollect = msrClassSubjects.stream().collect(Collectors.groupingBy(MsrClassSubject::getSubjectid));
+        for (Map.Entry<String, List<MsrClassSubject>> entry : scollect.entrySet()) {
+            List<MsrClassSubject> nearlineList = entry.getValue();
+            List<Double> classavgscore = new ArrayList<>();//班级平均分列表
+            List<Double> bzf = new ArrayList<>();//标准分列表
+            List<Double> cjl = new ArrayList<>();//超均率列表
+            List<Double> bjl = new ArrayList<>();//比均率列表
+            List<Double> zws = new ArrayList<>();//中位数列表
+            List<Double> ljc = new ArrayList<>();//离均差列表
+            List<Double> zs = new ArrayList<>();//众数列表
+            for (MsrClassSubject cs : nearlineList) {
+                classavgscore.add(cs.getClassavgscore());
+                bzf.add(cs.getBzf());
+                cjl.add(cs.getCjl());
+                bjl.add(cs.getBjl());
+                zws.add(cs.getZws());
+                ljc.add(cs.getLjc());
+                zs.add(cs.getZsmax());
+            }
+            Map<Double, Integer> pjfpm = MarkingUtil.fspm(classavgscore);//班级平均分排名
+            Map<Double, Integer> bzfpm = MarkingUtil.fspm(bzf);//标准分排名
+            Map<Double, Integer> cjlpm = MarkingUtil.fspm(cjl);//超均率排名
+            Map<Double, Integer> bjlpm = MarkingUtil.fspm(bjl);//比均率排名
+            Map<Double, Integer> zwspm = MarkingUtil.fspm(zws);//中位数排名
+            Map<Double, Integer> ljcpm = MarkingUtil.fspm(ljc);//离均差排名
+            Map<Double, Integer> zspm = MarkingUtil.fspm(zs);//众数排名
+            for (MsrClassSubject cs : nearlineList) {
+                cs.setClassavgrank(pjfpm.get(cs.getClassavgscore()));
+                cs.setBzfrank(bzfpm.get(cs.getBzf()));
+                cs.setCjlrank(cjlpm.get(cs.getCjl()));
+                cs.setBjlrank(bjlpm.get(cs.getBjl()));
+                cs.setZwsrank(zwspm.get(cs.getZws()));
+                cs.setLjcrank(ljcpm.get(cs.getLjc()));
+                cs.setZsrank(zspm.get(cs.getZsmax()));
+            }
+        }
+        msrClassSubjectMapper.insertList(msrClassSubjects);
+    }
 
+    //班级学科计算
+    private void setClassSubject(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassSubject> msrClassSubjects, Map<String, MsrClassSubject> csMap, String calformula) {
+        String subjectid;
+        MsrClassSubject zf = csMap.get("zf");
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            MsrClassSubject gs = csMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            studentList.sort(Comparator.comparing(MsrStudent::getStuscore));
+            MsrStudent minStudent = studentList.get(0);
+            int stunum = studentList.size();
+            MsrStudent maxStudent = studentList.get(stunum - 1);
+            Double fullscore = minStudent.getFullscore();
             MsrClassSubject msrClassSubject = new MsrClassSubject();
             msrClassSubject.setExamid(examid);
             msrClassSubject.setSubjectid(subjectid);
             msrClassSubject.setClassid(classid);
-            msrClassSubject.setFullscore(fullscore1);
+            msrClassSubject.setFullscore(fullscore);
+            msrClassSubject.setClassmaxscore(maxStudent.getStuscore());
+            msrClassSubject.setClassmaxrank(maxStudent.getSchoolrank());
+            msrClassSubject.setClassminscore(minStudent.getStuscore());
+            msrClassSubject.setClassminrank(minStudent.getSchoolrank());
+            List<Double> scores = studentList.stream().map(MsrStudent::getStuscore).collect(Collectors.toList());
+            double classavgscore = N_Utils.formatDouble(scores.stream().mapToDouble(Double::doubleValue).summaryStatistics().getAverage(), 2);
+            msrClassSubject.setClassavgscore(classavgscore);
+            double classavgrate = N_Utils.getDoubleDivideAndMulitiply(classavgscore, fullscore);
+            msrClassSubject.setClassavgrate(classavgrate);
+            msrClassSubject.setBzc(MarkingUtil.bzc(scores));
+            Double schoolavgscore = gs.getClassavgscore();
+            if (classid.equals(0)) {
+                msrClassSubject.setSchoolmaxscore(msrClassSubject.getClassmaxscore());
+                msrClassSubject.setSchoolminscore(msrClassSubject.getClassminscore());
+                msrClassSubject.setSchoolavgrate(msrClassSubject.getClassavgrate());
+                msrClassSubject.setSchoolavgrate(msrClassSubject.getClassavgrate());
+                msrClassSubject.setBzf(0.0);
+                msrClassSubject.setCjl(0.0);
+                msrClassSubject.setLjc(0.0);
+                msrClassSubject.setBjl(1.0);
+                msrClassSubject.setDfgxzs(0.0);
+                msrClassSubject.setPjfgxzs(0.0);
+            } else {
+                msrClassSubject.setSchoolmaxscore(gs.getClassmaxscore());
+                msrClassSubject.setSchoolminscore(gs.getClassminscore());
+                msrClassSubject.setSchoolavgrate(gs.getClassavgrate());
+                msrClassSubject.setSchoolavgrate(gs.getClassavgrate());
+                msrClassSubject.setBzf(MarkingUtil.bzf(classavgscore, schoolavgscore, gs.getBzc()));
+                msrClassSubject.setCjl(MarkingUtil.cjl(classavgscore, schoolavgscore));
+                msrClassSubject.setLjc(MarkingUtil.sub(classavgscore, schoolavgscore));
+                msrClassSubject.setBjl(1.0);
+                msrClassSubject.setDfgxzs(MarkingUtil.sub(classavgrate, zf.getClassavgrate()));
+                msrClassSubject.setPjfgxzs(MarkingUtil.sub(classavgscore, zf.getClassavgscore()));
+            }
+            msrClassSubject.setZws(MarkingUtil.zws(scores));
+            List<Double> zs = MarkingUtil.zs(scores);
+            msrClassSubject.setZs(JSON.toJSONString(zs));
+            msrClassSubject.setZsmax(zs.stream().max(Double::compareTo).orElse(0.0));
+            if (N_Utils.isNotEmpty(calformula)) {
+                calformula = calformula.replaceAll("平均分", msrClassSubject.getClassavgscore() + "");
+                calformula = calformula.replaceAll("标准差", msrClassSubject.getBzc() + "");
+                calformula = calformula.replaceAll("最高分", msrClassSubject.getClassmaxscore() + "");
+                calformula = calformula.replaceAll("最低分", msrClassSubject.getClassminscore() + "");
+                calformula = calformula.replaceAll("全科及格率", msrClassSubject.getQkjgl() + "");
+                calformula = calformula.replaceAll("超均率", msrClassSubject.getCjl() + "");
+                calformula = calformula.replaceAll("标准分", msrClassSubject.getBzf() + "");
+                calformula = calformula.replaceAll("中位数", msrClassSubject.getZws() + "");
+                calformula = calformula.replaceAll("离均差", msrClassSubject.getLjc() + "");
+                calformula = calformula.replaceAll("比均率", msrClassSubject.getBjl() + "");
+                calformula = calformula.replaceAll("众数", msrClassSubject.getZsmax() + "");
+                msrClassSubject.setZhl(MarkingUtil.evaluate(calformula));
+            }
+            msrClassSubject.setJhl(0.0);
+
+            if (classid.equals(0)) {
+                csMap.put(subjectid, msrClassSubject);
+            }
             msrClassSubjects.add(msrClassSubject);
+        }
+    }
+
+    //班级学科前60分析
+    public void saveClassTop(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrClassTop> msrClassTops = new ArrayList<>();//班级学科前60分析
+        Map<String, ClassTopVo> lsMap = new HashMap<>();//处于年级60%得分map
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, null);
+            String subjectid = entry.getKey().split("_")[1];
+            List<Double> scores = entry.getValue().stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+            Double lsscore = MarkingUtil.cynjdf(scores, 0.6);
+            List<MsrStudent> lsstudents = entry.getValue().stream().filter(s -> s.getStuscore().compareTo(lsscore) >= 0).collect(Collectors.toList());
+            ClassTopVo classTopVo = new ClassTopVo();
+            classTopVo.setSubjectid(subjectid);
+            classTopVo.setLsscore(lsscore);
+            classTopVo.setXtnum(lsstudents.size());
+            double average = lsstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
+            classTopVo.setXtavgscore(N_Utils.formatDouble(average, 2));
+            String xtstuids = lsstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+            classTopVo.setXtstuids(xtstuids);
+            lsMap.put(subjectid, classTopVo);
+        }
+        setClassTop(examid, collect, lsMap, msrClassTops);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassTop(examid, scCollect, lsMap, msrClassTops);
+        msrClassTopMapper.insertList(msrClassTops);
+    }
+
+    //班级学科前60计算
+    private void setClassTop(Integer examid, Map<String, List<MsrStudent>> scCollect, Map<String, ClassTopVo> lsMap
+            , List<MsrClassTop> msrClassTops) {
+        Integer totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<MsrStudent> studentList = entry.getValue();
+            totalnum = studentList.size();//区间总人数
 
             MsrClassTop msrClassTop = new MsrClassTop();
             msrClassTop.setExamid(examid);
@@ -357,24 +547,6 @@ public class MsrExamService {
             msrClassTop.setXtstuids(classTopVo.getXtstuids());
             msrClassTops.add(msrClassTop);
         }
-        msrSubjectClassMapper.insertList(msrSubjectClasses);
-        msrClassSubjectMapper.insertList(msrClassSubjects);
-        msrClassTopMapper.insertList(msrClassTops);
-
-        saveClassSubjectGrade(examid, "zh", msrStudents);//综合报告-班级学科四率等级分析
-        saveClassSubjectGrade(examid, "xj", msrStudents);//校级报告-班级学科四率等级分析
-        saveClassRankGroup(examid, msrStudents);//学科报告-班级学科名次分组分析
-        saveClassRankRate(examid, msrStudents);//综合报表-名次和比例分析
-        saveClassSection(examid, 1, "zh", msrStudents);//综合报表-分段统计
-        saveClassSection(examid, 2, "zh", msrStudents);//综合报表-累计统计
-        saveClassSection(examid, 1, "xj", msrStudents);//校级报告-分段统计
-        saveClassSection(examid, 1, "xk", msrStudents);//学科报告-分段统计
-        saveClassSection(examid, 1, "bj", msrStudents);//班级报告-分段统计
-        saveClassSection(examid, 1, "jxzl", msrStudents);//教学质量-分段统计
-        saveClassNearLine(examid, msrStudents);//分档上线统计
-        saveClassGoodBad(examid, "all", msrStudents);//重点学生-优劣名次统计
-
-        examMapper.updateExamState(examid, 3);
     }
 
     //重点学生-优劣名次统计
@@ -382,43 +554,42 @@ public class MsrExamService {
         List<MsrReportparam> params = getMsrReportParams(examid, "keystu", all);
         SzJsonVo fd = JSON.parseObject(params.get(0).getSzjson(), SzJsonVo.class);
         List<MsrClassGoodbad> classGoodbads = new ArrayList<>();
-        String subjectid;
         Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
         for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
-            Integer classid = 0;
-            subjectid = entry.getKey();
-            studentsDistinct(entry);
-            setClassGoodBag(examid, entry, fd, subjectid, classid, classGoodbads);
+            studentsDistinct(entry, rsMap);
+            setClassGoodBag(examid, entry, fd, classGoodbads, rsMap);
         }
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
-            String key = entry.getKey();
-            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
-            subjectid = key.split("_")[1];
-            setClassGoodBag(examid, entry, fd, subjectid, classid, classGoodbads);
+            setClassGoodBag(examid, entry, fd, classGoodbads, rsMap);
         }
         msrClassGoodbadMapper.insertList(classGoodbads);
     }
 
     //学生去重
-    private void studentsDistinct(Map.Entry<String, List<MsrStudent>> entry) {
+    private void studentsDistinct(Map.Entry<String, List<MsrStudent>> entry, Map<String, Integer> rsMap) {
         //list根据学生id去重
         Map<Integer, MsrStudent> map = new HashMap<>();
         for (MsrStudent student : entry.getValue()) {
             map.putIfAbsent(student.getStudentid(), student);
         }
-        List<MsrStudent> list = map.values().stream().collect(Collectors.toList());
+        List<MsrStudent> list = new ArrayList<>(map.values());
         entry.setValue(list);
+        if (rsMap != null) rsMap.put(list.get(0).getSubjectid(), list.size());
     }
 
     //重点学生-优劣名次计算
-    private void setClassGoodBag(Integer examid, Map.Entry<String, List<MsrStudent>> entry, SzJsonVo fd, String subjectid, Integer classid, List<MsrClassGoodbad> classGoodbads) {
+    private void setClassGoodBag(Integer examid, Map.Entry<String, List<MsrStudent>> entry, SzJsonVo fd, List<MsrClassGoodbad> classGoodbads, Map<String, Integer> rsMap) {
+        String key = entry.getKey();
+        Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+        String subjectid = key.split("_")[1];
         int totalnum;
         Integer goodtype = fd.getGoodtype();
         Integer badtype = fd.getBadtype();
         List<MsrStudent> studentList = entry.getValue().stream().sorted(Comparator.comparing(MsrStudent::getSchoolrank)).collect(Collectors.toList());
         Double avgScore = N_Utils.formatDouble(studentList.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2);
-        totalnum = studentList.size();//区间总人数
+        totalnum = rsMap.get(subjectid);//科目总人数
         Integer goodvalue = fd.getGoodvalue();
         Integer badvalue = fd.getBadvalue();
         List<MsrStudent> yxStudents;//优秀学生列表
@@ -473,23 +644,18 @@ public class MsrExamService {
         List<SzJsonVo> vos = JSON.parseArray(params.get(0).getSzjson(), SzJsonVo.class);
         Map<Integer, List<Integer>> zfSx = null;//学生总分是否上线
         List<MsrClassNearline> classNearlines = new ArrayList<>();
-        String subjectid;
         Map<String, List<MsrStudent>> collect0 = getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
         for (Map.Entry<String, List<MsrStudent>> entry : collect0.entrySet()) {
-            Integer classid = 0;
-            subjectid = entry.getKey();
-            studentsDistinct(entry);
-            if (subjectid.equals("zf")) {
+            studentsDistinct(entry, rsMap);
+            if (entry.getKey().endsWith("zf")) {
                 zfSx = setZfsxMap(entry.getValue(), qjMap, tMap);
             }
-            setClassNearLine(examid, entry, qjMap, subjectid, tMap, vos, classid, zfSx, classNearlines);
+            setClassNearLine(examid, entry, qjMap, tMap, vos, zfSx, classNearlines, rsMap);
         }
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
-            String key = entry.getKey();
-            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
-            subjectid = key.split("_")[1];
-            setClassNearLine(examid, entry, qjMap, subjectid, tMap, vos, classid, zfSx, classNearlines);
+            setClassNearLine(examid, entry, qjMap, tMap, vos, zfSx, classNearlines, rsMap);
         }
         Map<String, List<MsrClassNearline>> collect = classNearlines.stream().collect(Collectors.groupingBy(l -> l.getSubjectid() + "_" + l.getDworder()));
         for (Map.Entry<String, List<MsrClassNearline>> entry : collect.entrySet()) {
@@ -508,21 +674,28 @@ public class MsrExamService {
 
     //获取科学分组学生
     private Map<String, List<MsrStudent>> getSubjectCollect(List<MsrStudent> msrStudents) {
-        return msrStudents.stream().collect(Collectors.groupingBy(s -> s.getSubjectid(), LinkedHashMap::new, Collectors.toList()));
+        Map<String, List<MsrStudent>> map = new LinkedHashMap<>();
+        LinkedHashMap<String, List<MsrStudent>> collect = msrStudents.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid, LinkedHashMap::new, Collectors.toList()));
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            map.put("0_" + entry.getKey(), entry.getValue());
+        }
+        return map;
     }
 
     //分档上线计算
     private void setClassNearLine(Integer examid, Map.Entry<String, List<MsrStudent>> entry, Map<String, List<SzJsonVo>> qjMap
-            , String subjectid, Map<String, Integer> tMap, List<SzJsonVo> vos, Integer classid
-            , Map<Integer, List<Integer>> zfSx, List<MsrClassNearline> classNearlines) {
-        int totalnum;
+            , Map<String, Integer> tMap, List<SzJsonVo> vos, Map<Integer, List<Integer>> zfSx
+            , List<MsrClassNearline> classNearlines, Map<String, Integer> rsMap) {
+        String key = entry.getKey();
+        Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+        String subjectid = key.split("_")[1];
+        int totalnum = rsMap.get(subjectid);
         List<SzJsonVo> list = qjMap.get(subjectid);
         Integer rptype = tMap.get(subjectid);
         List<MsrStudent> studentList = entry.getValue();
         if (rptype.equals(3)) {
             studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
         }
-        totalnum = studentList.size();//区间总人数
         Double max = null;
         Integer minRank = null;
         int minIndex = 0;
@@ -595,12 +768,11 @@ public class MsrExamService {
                 nearline.setStuids2(ssxIds.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
                 //总分上线学科未上线人数
                 List<Integer> dksxIds = qjstudents.stream().map(MsrStudent::getStudentid).collect(Collectors.toList());
-                List<Integer> zfsxxkwsxIds = new ArrayList<>();
-                zfsxxkwsxIds.addAll(zfsxIds);
+                List<Integer> zfsxxkwsxIds = new ArrayList<>(zfsxIds);
                 zfsxxkwsxIds.removeAll(dksxIds);
                 int zfsxxkwsxnum = zfsxxkwsxIds.size();
                 nearline.setZfsxxkwsxnum(zfsxxkwsxnum);
-                nearline.setStuids5(zfsxxkwsxIds.stream().map(s -> s.toString()).collect(Collectors.joining(",")));
+                nearline.setStuids5(zfsxxkwsxIds.stream().map(Object::toString).collect(Collectors.joining(",")));
                 nearline.setGxrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, zfsxnum));
                 nearline.setMzxrate(N_Utils.getIntegerDivideAndMulitiply(ssxnum, qjnum));
             }
@@ -629,7 +801,7 @@ public class MsrExamService {
         if (rptype.equals(3)) {
             studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
         }
-        totalnum = studentList.size();//区间总人数
+        totalnum = studentList.size();//总人数
         Double max = null;
         Integer minRank = null;
         int minIndex = 0;
@@ -690,8 +862,19 @@ public class MsrExamService {
         }
 
         List<MsrClassSection> classSections = new ArrayList<>();
-        String subjectid;
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, null);
+        }
+        setClassSection(examid, type, reportcode, collect, fdMap, classSections);
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSection(examid, type, reportcode, scCollect, fdMap, classSections);
+        msrClassSectionMapper.insertList(classSections);
+    }
+
+    //分段统计-计算
+    private void setClassSection(Integer examid, Integer type, String reportcode, Map<String, List<MsrStudent>> scCollect, Map<String, List<RankGroupVo>> fdMap, List<MsrClassSection> classSections) {
+        String subjectid;
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
             String key = entry.getKey();
             Integer classid = N_Utils.obj2Int(key.split("_")[0]);
@@ -729,22 +912,37 @@ public class MsrExamService {
                 classSections.add(classSection);
             }
         }
-        msrClassSectionMapper.insertList(classSections);
     }
 
     //学科报告-班级学科名次分组分析
     public void saveClassRankGroup(Integer examid, List<MsrStudent> msrStudents) {
         List<MsrClassRankgroup> classRankGroups = new ArrayList<>();
-        int groupNum = 10;
-        String subjectid;
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, List<RankGroupVo>> groupsMap = new HashMap<>();
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, rsMap);
+            List<MsrStudent> studentList = entry.getValue();
+            int maxRank = studentList.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMax();
+            List<RankGroupVo> groups = MarkingUtil.rankGroup(maxRank, 10);
+            groupsMap.put(studentList.get(0).getSubjectid(), groups);
+        }
+        setClassRankGroup(examid, collect, classRankGroups, groupsMap);
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassRankGroup(examid, scCollect, classRankGroups, groupsMap);
+        msrClassRankgroupMapper.insertList(classRankGroups);
+    }
+
+    //学科报告-班级学科名次分组计算
+    private void setClassRankGroup(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassRankgroup> classRankGroups, Map<String, List<RankGroupVo>> groupsMap) {
+        String subjectid;
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
             String key = entry.getKey();
             Integer classid = N_Utils.obj2Int(key.split("_")[0]);
             subjectid = key.split("_")[1];
             List<MsrStudent> studentList = entry.getValue();
-            int maxRank = studentList.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMax();
-            List<RankGroupVo> groups = MarkingUtil.rankGroup(maxRank, groupNum);
+            List<RankGroupVo> groups = groupsMap.get(subjectid);
             for (RankGroupVo group : groups) {
                 int maxvalue = group.getMaxvalue();
                 int minvalue = group.getMinvalue();
@@ -760,7 +958,6 @@ public class MsrExamService {
                 classRankGroups.add(cg);
             }
         }
-        msrClassRankgroupMapper.insertList(classRankGroups);
     }
 
     //综合报表-名次和比例分析
@@ -774,26 +971,27 @@ public class MsrExamService {
             tMap.put(subjectid, param.getRptype());
         }
         List<MsrClassRankrate> classRankrates = new ArrayList<>();
-        String subjectid;
-        int totalnum;
-        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
-        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
-            String key = entry.getKey();
-            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
-            subjectid = key.split("_")[1];
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, List<RankRateGroupVo>> sgMap = new HashMap<>();//学科名次分组map
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, rsMap);
+            List<RankRateGroupVo> subjectGroupList = new ArrayList<>();//学科名次分组列表
+            String subjectid = entry.getKey().split("_")[1];
             List<SzJsonVo> list = qjMap.get(subjectid);
             Integer rptype = tMap.get(subjectid);
             List<MsrStudent> studentList = entry.getValue();
             if (rptype.equals(3)) {
                 studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
             }
-            totalnum = studentList.size();//区间总人数
+            int totalnum = studentList.size();//总人数
             Double max = null;
             Integer minRank = null;
             int minIndex = 0;
             Object minRate = null;
             for (SzJsonVo rg : list) {
                 Object djvalue = rg.getDjvalue();
+                RankRateGroupVo group = new RankRateGroupVo();
                 List<MsrStudent> qjstudents;
                 String ztname;
                 String ctname;
@@ -801,23 +999,28 @@ public class MsrExamService {
                     ztname = "前" + djvalue + "名";
                     Integer rank = N_Utils.obj2Int(djvalue);
                     if (minRank == null) {
-                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) >= 0).collect(Collectors.toList());
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
                     } else {
                         Integer finalMinRank = minRank;
-                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(finalMinRank) >= 0 && s.getSchoolrank().compareTo(rank) < 0).collect(Collectors.toList());
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(finalMinRank) > 0 && s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                        group.setMinrank(minRank);
                     }
+                    group.setMaxrank(rank);
                     minRank = rank;
                     double minScore = N_Utils.handleInfinity(qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getMin());
                     ctname = ">=" + minScore + "分";
                 } else if (rptype.equals(2)) {//按分数
                     ztname = ">=" + djvalue + "分";
                     Double score = MarkingUtil.objToDouble(djvalue);
+                    double minScore = score;
                     if (max == null) {
                         qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0).collect(Collectors.toList());
                     } else {
                         Double finalMax = max;
                         qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0 && s.getStuscore().compareTo(finalMax) < 0).collect(Collectors.toList());
+                        group.setMaxscore(max);
                     }
+                    group.setMinscore(minScore);
                     max = score;
                     minRank = qjstudents.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMin();
                     ctname = "前" + minRank + "名";
@@ -836,16 +1039,65 @@ public class MsrExamService {
                     double minScore = N_Utils.handleInfinity(statistics.getMin());
                     double maxScore = N_Utils.handleInfinity(statistics.getMax());
                     ctname = "[" + minScore + "-" + maxScore + "]";
+                    group.setMaxscore(maxScore);
+                    group.setMinscore(minScore);
+                }
+                group.setRtype(rptype);
+                group.setZtname(ztname);
+                group.setCtname(ctname);
+                subjectGroupList.add(group);
+            }
+            sgMap.put(subjectid, subjectGroupList);
+        }
+        setClassRankRate(examid, collect, classRankrates, sgMap, rsMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassRankRate(examid, scCollect, classRankrates, sgMap, rsMap);
+        msrClassRankrateMapper.insertList(classRankrates);
+    }
+
+    //综合报表-名次和比例计算
+    private void setClassRankRate(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassRankrate> classRankrates, Map<String, List<RankRateGroupVo>> sgMap
+            , Map<String, Integer> rsMap) {
+        int totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            totalnum = rsMap.get(subjectid);
+            List<RankRateGroupVo> list = sgMap.get(subjectid);
+            Integer rptype = list.get(0).getRtype();
+            List<MsrStudent> studentList = entry.getValue();
+            if (rptype.equals(3)) {
+                studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
+            }
+            int stunum = studentList.size();//参考人数
+            for (int i = 0; i < list.size(); i++) {
+                RankRateGroupVo rg = list.get(i);
+                List<MsrStudent> qjstudents;
+                if (rptype.equals(1)) {//按名次
+                    if (i == 0) {
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rg.getMaxrank()) >= 0).collect(Collectors.toList());
+                    } else {
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rg.getMaxrank()) >= 0 && s.getSchoolrank().compareTo(rg.getMinrank()) < 0).collect(Collectors.toList());
+                    }
+                } else {//按分数
+                    if (i == 0) {
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(rg.getMinscore()) >= 0).collect(Collectors.toList());
+                    } else {
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(rg.getMinscore()) >= 0 && s.getStuscore().compareTo(rg.getMaxscore()) < 0).collect(Collectors.toList());
+                    }
                 }
                 int qjnum = qjstudents.size();
                 MsrClassRankrate rankrate = new MsrClassRankrate();
                 rankrate.setExamid(examid);
                 rankrate.setSubjectid(subjectid);
                 rankrate.setClassid(classid);
-                rankrate.setStunum(totalnum);
+                rankrate.setStunum(stunum);
                 rankrate.setRtype(rptype);
-                rankrate.setZtname(ztname);
-                rankrate.setCtname(ctname);
+                rankrate.setZtname(rg.getZtname());
+                rankrate.setCtname(rg.getCtname());
                 rankrate.setRnum(qjnum);
                 rankrate.setRrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
                 String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
@@ -853,23 +1105,36 @@ public class MsrExamService {
                 classRankrates.add(rankrate);
             }
         }
-        msrClassRankrateMapper.insertList(classRankrates);
     }
 
     //班级学科四率等级分析
     public void saveClassSubjectGrade(Integer examid, String reportcode, List<MsrStudent> msrStudents) {
-        Map<String, List<SzJsonVo>> qjMap = getReportParams(examid, "scorerate", reportcode);
+        Map<String, List<SzJsonVo>> qjMap = formatSzJson(getMsrReportParams(examid, "scorerate", reportcode));
         List<MsrClassSubjectGrade> msrClassSubjectGrades = new ArrayList<>();//班级学科分析
-        String subjectid;
-        int totalnum;
+        Map<String, List<MsrStudent>> collect = getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            studentsDistinct(entry, rsMap);
+        }
+        setClassSubjectGrade(examid, reportcode, collect, qjMap, msrClassSubjectGrades, rsMap);
         Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSubjectGrade(examid, reportcode, scCollect, qjMap, msrClassSubjectGrades, rsMap);
+        msrClassSubjectGradeMapper.insertList(msrClassSubjectGrades);
+    }
+
+    //班级学科四率等级计算
+    private void setClassSubjectGrade(Integer examid, String reportcode, Map<String, List<MsrStudent>> scCollect
+            , Map<String, List<SzJsonVo>> qjMap, List<MsrClassSubjectGrade> msrClassSubjectGrades
+            , Map<String, Integer> rsMap) {
+        int totalnum;
+        String subjectid;
         for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
             String key = entry.getKey();
             Integer classid = N_Utils.obj2Int(key.split("_")[0]);
             subjectid = key.split("_")[1];
             List<SzJsonVo> list = qjMap.get(subjectid);
             List<MsrStudent> studentList = entry.getValue();
-            totalnum = studentList.size();//区间总人数
+            totalnum = rsMap.get(subjectid);//科目总人数
             Double fullscore1 = studentList.get(0).getFullscore();
             for (SzJsonVo rg : list) {
                 String qjname = rg.getDjkey();
@@ -910,13 +1175,6 @@ public class MsrExamService {
                 classSubjectGrade.setRangenumrank(rspm.get(classSubjectGrade.getRangenum()));
             }
         }
-        msrClassSubjectGradeMapper.insertList(msrClassSubjectGrades);
-    }
-
-    //获取报告参数
-    private Map<String, List<SzJsonVo>> getReportParams(Integer examid, String rpbelong, String reportcode) {
-        List<MsrReportparam> list = getMsrReportParams(examid, rpbelong, reportcode);
-        return formatSzJson(list);
     }
 
     //格式化报告参数
@@ -931,7 +1189,7 @@ public class MsrExamService {
     //获取报告参数
     private List<MsrReportparam> getMsrReportParams(Integer examid, String rpbelong, String reportcode) {
         List<MsrReportparam> list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, reportcode);
-        if (N_Utils.isListEmpty(list)) {
+        if (N_Utils.isListEmpty(list) && !"all".equals(reportcode)) {
             list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, "all");
         }
         return list;
@@ -951,7 +1209,7 @@ public class MsrExamService {
         List<Double> scoreRates = schoolStudents2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
         double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
         msrSubject.setDfllc(dfllc);
-        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, avgscore));
+        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, msrSubject.getScorerate()));
         msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
         msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
         msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));

smarking/src/main/java/com/xhkjedu/smarking/utils/MarkingUtil.java

@@ -469,7 +469,7 @@ public class MarkingUtil {
         if (N_Utils.isListEmpty(list)) return modes;
 
         // 使用HashMap来统计每个元素出现的次数
-        Map<Double, Long> countMap = list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
+        Map<Double, Long> countMap = list.stream().filter(s -> s > 0).collect(Collectors.groupingBy(e -> e, Collectors.counting()));
 
         long maxCount = 0;
         // 找出最大的出现次数
@@ -729,6 +729,61 @@ public class MarkingUtil {
         }
         return "";
     }
+
+    private static int index = 0;
+    //根据表达式计算
+    public static double evaluate(String expression) {
+        index = 0;
+        return parseExpression(expression);
+    }
+
+    private static double parseExpression(String expr) {
+        try {
+            double result = parseTerm(expr);
+            while (index < expr.length() && (expr.charAt(index) == '+' || expr.charAt(index) == '-')) {
+                char op = expr.charAt(index);
+                index++;
+                if (op == '+') {
+                    result += parseTerm(expr);
+                } else if (op == '-') {
+                    result -= parseTerm(expr);
+                }
+            }
+            return result;
+        } catch (Exception e) {
+            return 0.0;
+        }
+    }
+
+    private static double parseTerm(String expr) {
+        double result = parseFactor(expr);
+        while (index < expr.length() && (expr.charAt(index) == '*' || expr.charAt(index) == '/')) {
+            char op = expr.charAt(index);
+            index++;
+            if (op == '*') {
+                result *= parseFactor(expr);
+            } else if (op == '/') {
+                result /= parseFactor(expr);
+            }
+        }
+        return result;
+    }
+
+    private static double parseFactor(String expr) {
+        if (expr.charAt(index) == '(') {
+            index++;  // Skip '('
+            double result = parseExpression(expr);
+            index++;  // Skip ')'
+            return result;
+        } else {
+            int start = index;
+            while (index < expr.length() && Character.isDigit(expr.charAt(index))) {
+                index++;
+            }
+            return Double.parseDouble(expr.substring(start, index));  // Convert substring to double
+        }
+    }
+
     public static void main(String[] args) {
         List<String> options = Arrays.asList("A","B","D","F","","C","E");
         List<String> newOptions = options.stream().map(s -> s != null && !s.isEmpty() ? s : "未作答").sorted().collect(Collectors.toList());

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportclass/RankRateGroupVo.java

@@ -0,0 +1,26 @@
+package com.xhkjedu.smarking.vo.report.reportclass;
+
+import lombok.Data;
+
+/**
+ * @Description 名次和比例分组
+ * @Author YWX
+ * @Date 2024/12/26 14:17
+ **/
+@Data
+public class RankRateGroupVo {
+    //主类型名（综合里表格头展示用）
+    private String ztname;
+    //次类型名（综合里表格头展示用）
+    private String ctname;
+    //类型（1名次 2分数 3比例）
+    private Integer rtype;
+    //最大名次
+    private Integer maxrank;
+    //最小名次
+    private Integer minrank;
+    //最高分
+    private Double maxscore;
+    //最低分
+    private Double minscore;
+}