统计打破得分记录的次数以及打破得分记录的状态是最低的得分记录打破还是最高的得分记录打破

/**
 * 统计打破得分记录的次数以及打破得分记录的状态是最低的得分记录打破还是最高的得分记录打破
 * @param scores
 * @return
 */
public static List<Integer> breakingRecords(List<Integer> scores){
    if(scores==null){
        return null;
    }
    if (scores.isEmpty()){
        return null;
    }
    if (scores.size()==1){
        return null;
    }
    if (scores.size() < 1 || scores.size()>1000) {
        return null;
    }
    int val=1;
    for (int i = 0; i < 8; i++) {
        val*=10;
    }
    for (Integer score : scores) {
        if (score<0 || score>val){
            return null;
        }
    }
    ArrayList<CustomerScoreDef> customerScoreDefs = new ArrayList<>();
    int count=scores.size();
    while (count>0){
        Integer  inicializeUplayScore= scores.get(1);
        scores.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1>o2){
                    return 1;
                } else if (o1<o2) {
                    return -1;
                }
                return 0;
            }
        });
        Integer maxScore = scores.get(0);
        Integer minScore = scores.get(scores.size() - 1);
        if (inicializeUplayScore>maxScore){
            CustomerScoreDef customerScoreDef = new CustomerScoreDef();
            customerScoreDef.setId(UUID.randomUUID().toString());
            customerScoreDef.setBreakScoreFrequence(1);
            customerScoreDef.setGMaxUpLayerScore(true);
            customerScoreDefs.add(customerScoreDef);
        }else if(inicializeUplayScore<minScore){
            CustomerScoreDef customerScoreDef = new CustomerScoreDef();
            customerScoreDef.setId(UUID.randomUUID().toString());
            customerScoreDef.setLMinLowLayerScore(true);
            customerScoreDef.setBreakScoreFrequence(1);
            customerScoreDefs.add(customerScoreDef);
        }else {
            CustomerScoreDef customerScoreDef = new CustomerScoreDef();
            customerScoreDef.setId(UUID.randomUUID().toString());
            customerScoreDef.setBreakScoreFrequence(0);
            customerScoreDef.setGMaxUpLayerScore(false);
            customerScoreDef.setLMinLowLayerScore(false);
            customerScoreDefs.add(customerScoreDef);
        }
        count--;
    }
    HashMap<String, Integer> integerIntegerHashMap = new HashMap<>();
    customerScoreDefs.forEach(e->{
        Integer breakScoreFrequence = e.getBreakScoreFrequence();
        if (breakScoreFrequence==1){
            if (integerIntegerHashMap.get("maxUpLayer1")>=1){
                integerIntegerHashMap.put("maxUpLayer1",integerIntegerHashMap.get(e.getBreakScoreFrequence())+1);
            }else if (integerIntegerHashMap.get("maxUpLayer1")<1){
                integerIntegerHashMap.put("maxUplayer1",1);
            } else if (integerIntegerHashMap.get("minLowLayer1")>=1) {
                integerIntegerHashMap.put("minLowLayer1",integerIntegerHashMap.get("minLowLayer1")+1);
            } else if (integerIntegerHashMap.get("minLowLayer1")<1) {
                integerIntegerHashMap.put("minLowLayer1",1);
            }
        }
    });
    ArrayList<CustRetResult> custRetResults = new ArrayList<>();
    int breakRecoredTimes=0;
    for (Map.Entry<String,Integer> entry : integerIntegerHashMap.entrySet()) {
        CustRetResult custRetResult = new CustRetResult();
        custRetResult.setId(UUID.randomUUID().toString());
        breakRecoredTimes += entry.getValue();
        custRetResult.setBreakScoreRecoredTimes(breakRecoredTimes);
        if("maxUpLayer1".equals(entry.getKey())){
            custRetResult.setIsBreakMaxUpLayerScoreOrNot(0);
        } else if ("minLowLayer1".equals(entry.getKey())) {
            custRetResult.setIsBreakMaxUpLayerScoreOrNot(1);
        }
        custRetResults.add(custRetResult);
    }
    ArrayList<Integer> integers = new ArrayList<>();
    Random random = new Random();
    int i = random.nextInt(custRetResults.size());
    CustRetResult custRetResult = custRetResults.get(i);
    integers.add(custRetResult.getBreakScoreRecoredTimes());
    integers.add(custRetResult.getIsBreakMaxUpLayerScoreOrNot());
    return integers;
}

class CustRetResult{
    private String id;
    private Integer breakScoreRecoredTimes;
    private Integer isBreakMaxUpLayerScoreOrNot; // 打破最高记录初始化 0，打破最低记录初始化 1
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getBreakScoreRecoredTimes() {
        return breakScoreRecoredTimes;
    }

    public void setBreakScoreRecoredTimes(Integer breakScoreRecoredTimes) {
        this.breakScoreRecoredTimes = breakScoreRecoredTimes;
    }

    public Integer getIsBreakMaxUpLayerScoreOrNot() {
        return isBreakMaxUpLayerScoreOrNot;
    }

    public void setIsBreakMaxUpLayerScoreOrNot(Integer isBreakMaxUpLayerScoreOrNot) {
        this.isBreakMaxUpLayerScoreOrNot = isBreakMaxUpLayerScoreOrNot;
    }
}
class CustomerScoreDef{
    private String id;
    private Boolean isGMaxUpLayerScore;
    private Boolean isLMinLowLayerScore;
    private Integer breakScoreFrequence;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Boolean getGMaxUpLayerScore() {
        return isGMaxUpLayerScore;
    }

    public void setGMaxUpLayerScore(Boolean GMaxUpLayerScore) {
        isGMaxUpLayerScore = GMaxUpLayerScore;
    }

    public Boolean getLMinLowLayerScore() {
        return isLMinLowLayerScore;
    }

    public void setLMinLowLayerScore(Boolean LMinLowLayerScore) {
        isLMinLowLayerScore = LMinLowLayerScore;
    }

    public Integer getBreakScoreFrequence() {
        return breakScoreFrequence;
    }

    public void setBreakScoreFrequence(Integer breakScoreFrequence) {
        this.breakScoreFrequence = breakScoreFrequence;
    }
}