c# - Conversion d'un JSONArray en un nouveau JSONArray en fonction du type qu'il contient

Question

Il y a maintenant une LISTE :

[
        {
            "type":"呼吸系统",
            "illness":"肺气肿",
            "quotaName": "血压"
        },
        {
            "type":"呼吸系统",
            "illness":"肺气肿",
            "quotaName": "血常规"
        },
       {
            "type":"呼吸系统",
            "illness":"哮喘",
            "quotaName": "血常规"
        },
       {
            "type":"循环系统",
            "illness":"高血压",
            "quotaName": "心电图"
        },
       {
            "type":"循环系统",
            "illness":"高血压",
            "quotaName": "心电彩超"
        }
    ]

La liste que je veux :

[
        {
            "type":"呼吸系统",
            "illnessList":[
                {
                   "name":"肺气肿", 
                   "quotaList":[
                       {
                           "name":"血压"
                       },
                       {
                           "name":"血常规"
                       }
                   ]
                },
                {
                    "name":"哮喘",
                    "quotaList":[
                        {
                            "name":"血常规"
                        }
                    ]
                }
            ]
        },
        {
            "type":"循环系统",
            "illnessList":[
                {
                    "name":"高血压",
                    "quotaList":[
                        {
                            "name":"心电图"
                        },
                        {
                            "name":"心电彩超"
                        }
                    ]
                }
            ]
        }
    ]

La liste originale, tous les systèmes de maladies, maladies et indicateurs de détection de maladies sont combinés

Je souhaite obtenir une liste basée sur la classification des types, mais je ne trouve toujours pas l'idée

Boucle, après l'avoir parcourue plusieurs fois, j'ai l'impression que ma tête est confuse. S'il vous plaît, donnez-moi quelques idées

.

Answer 1

Selon les exigences d'entrée et de sortie du questionneur, commencez simplement par unJSONArray转换到另一个JSONArray...感觉输出的JSONArray无非是按照了两个属性进行了归类，其实结构应该类似于Map<String,Map<String,List<String>>，所以我的想法就是把输入的JSONArray要转化为Map<String, Map<String,List<String>>的结构即可...而看到我刚才说的按照属性归类...那...很显然...噔噔噔！！！...心中自然浮现了Java8的Collectors.groupingBy...直接无脑groupingBy

Voici ma petite idée et mon code :
Comme il est orienté objet, j'ai d'abord créé un objet Bo d'entréeFromDataBo

@Getter
@Setter
public class FromDataBo {
    private String type;
    private String illness;
    private String quotaName;
}

Ensuite, il y a l'objet de sortie créé selon le format de sortieToDataBo (Vous pouvez d'abord ignorer la méthode annotée... c'est juste pour la conversion, vous pouvez d'abord regarder la structure des données)

@Getter
@Setter
public class ToDataBo {
    private String type;
    private List<ToDataIllnessBo> illnessList;

    /**
     * map转化为List<ToDataBo>
     * @param map
     * @return
     */
    public static List<ToDataBo> createByMap(Map<String, Map<String, List<String>>> map){
        return map.entrySet().stream().map(ToDataBo::of).collect(Collectors.toList());
    }

    /**
     * 一个Map.Entry<String, Map<String, List<String>>>对应转化为一个ToDataBo
     * @param entry
     * @return
     */
    public static ToDataBo of(Map.Entry<String, Map<String, List<String>>> entry){
        ToDataBo dataBo = new ToDataBo();
        dataBo.setType(entry.getKey());
        dataBo.setIllnessList(entry.getValue().entrySet().stream().map(ToDataIllnessBo::of).collect(Collectors.toList()));
        return dataBo;
    }
    
    @Getter
    @Setter
    static class ToDataIllnessBo{
        private String name;
        private List<ToDataQuotaBo> quotaList;

        /**
         * 一个Map.Entry<String, List<String>>对应转化为一个ToDataIllnessBo
         * @param entry
         * @return
         */
        public static ToDataIllnessBo of(Map.Entry<String, List<String>> entry){
            ToDataIllnessBo dataIllnessBo = new ToDataIllnessBo();
            dataIllnessBo.setName(entry.getKey());
            dataIllnessBo.setQuotaList(entry.getValue().stream().map(ToDataQuotaBo::new).collect(Collectors.toList()));
            return dataIllnessBo;
        }
    }

    @Getter
    @Setter
    @AllArgsConstructor
    static class ToDataQuotaBo {
        private String name;
    }
}

Maintenant que les objets d'entrée et de sortie sont en place, nous pouvons classer les attributs les plus importants par attributs. Je vais d'abord voir l'estimation de la conversion en Map<String,Map<String,List<String>>的代码贴出来...主要就是这个嘛...注释嘛，熟悉lamdba en un coup d'œil... Si vous ne la connaissez pas, apprenez-en plus. ça

Map<String, Map<String, List<String>>> collect = fromDataBos.stream().collect(
                                // 按照type分类
                                Collectors.groupingBy(FromDataBo::getType,
                                        // 按照type分类后，同一类的数据再按照illness分类
                                        Collectors.groupingBy(FromDataBo::getIllness,
                                                // 按照type分类，再按照illness分类后，同一类的数据取其中的QuotaName并转化为集合
                                                Collectors.mapping(FromDataBo::getQuotaName, Collectors.toList()))));

À la fin se trouve le code complet du test et les résultats, le dernier result对象就是你需要的输出JSONArray

public class Test1 {
    public static void main(String[] args) {
        String from = "[\n" +
                "        {\n" +
                "            \"type\":\"呼吸系统\",\n" +
                "            \"illness\":\"肺气肿\",\n" +
                "            \"quotaName\": \"血压\"\n" +
                "        },\n" +
                "        {\n" +
                "            \"type\":\"呼吸系统\",\n" +
                "            \"illness\":\"肺气肿\",\n" +
                "            \"quotaName\": \"血常规\"\n" +
                "        },\n" +
                "       {\n" +
                "            \"type\":\"呼吸系统\",\n" +
                "            \"illness\":\"哮喘\",\n" +
                "            \"quotaName\": \"血常规\"\n" +
                "        },\n" +
                "       {\n" +
                "            \"type\":\"循环系统\",\n" +
                "            \"illness\":\"高血压\",\n" +
                "            \"quotaName\": \"心电图\"\n" +
                "        },\n" +
                "       {\n" +
                "            \"type\":\"循环系统\",\n" +
                "            \"illness\":\"高血压\",\n" +
                "            \"quotaName\": \"心电彩超\"\n" +
                "        }\n" +
                "    ]";
                
        // 把输入的JSONArray字符串转化为FromDataBo集合
        List<FromDataBo> fromDataBos = JSONArray.parseArray(from, FromDataBo.class);
        // 归类
        Map<String, Map<String, List<String>>> collect = fromDataBos.stream().collect(
                                // 按照type分类
                                Collectors.groupingBy(FromDataBo::getType,
                                        // 按照type分类后，同一类的数据再按照illness分类
                                        Collectors.groupingBy(FromDataBo::getIllness,
                                                // 按照type分类，再按照illness分类后，同一类的数据取其中的QuotaName并转化为集合
                                                Collectors.mapping(FromDataBo::getQuotaName, Collectors.toList()))));
        // 归类后的map转化为输出对象ToDataBo集合
        List<ToDataBo> toDataBos = ToDataBo.createByMap(collect);
        
        // 我是输出对象，我在这
        JSONArray result = JSONArray.parseArray(JSONArray.toJSONString(toDataBos));
        System.out.println(result);
    }
}

Résultats des tests :

Juste comme ça...

Answer 2

Est-ce que cela ne vient pas du backend ? Vous n’avez pas besoin de le gérer, il suffit d’en informer le backend. Ou vous pouvez simplement utiliser ce qu’ils crachent pour obtenir votre effet.
C'est juste que vous voulez éviter les ennuis. Traiter directement en boucle.
Utilisez le tableau ci-dessus et effectuez le traitement dans la boucle, qui est le même que celui que vous traiterez plus tard. Pas aussi bon que le prétraitement. Haute performance. Ce qui suit est le style standard.
L'interface est publiée.

Answer 3

Code adresse
http://jsbin.com/roqejoficu/e...

var  convertData =  function(data){
    let result = [];
    var level1Obj = {};
    var level2Obj = {};
    var level3Obj = {};
  
    
    data.forEach(function (item, index, arr) {

        //一层对象
        level1Obj[item.type] = {};
        level1Obj[item.type]["type"] = item.type;

        //2层对象
        level2Obj[item.type+item.illness] = {};
        level2Obj[item.type+item.illness]["p1"] = item.type;
        level2Obj[item.type+item.illness]["type"] = item.illness;


        //3层对象
        level3Obj[index] = {};
        level3Obj[index]["p1"] = item.type;
        level3Obj[index]["p2"] = item.illness;
        level3Obj[index]["type"] = item.quotaName;
    });

    
    for (var level1 in level1Obj) {
        var o1 = {};
        o1.type = level1Obj[level1].type;
        o1.list = [];
        result.push(o1);

        for (var level2 in level2Obj) {
            if (level2Obj[level2].p1 == level1Obj[level1].type) {
                var o2 = {};

                o2.type = level2Obj[level2].type;
                o2.list = [];
                o1.list.push(o2);

                for (var level3 in level3Obj) {
                    if (level3Obj[level3].p1 == level1Obj[level1].type && level3Obj[level3].p2 == level2Obj[level2].type) {
                        var o3 = {};
                        o3.type = level3Obj[level3].type;
                        o2.list.push(o3);
                    }
                }
            }
        }
    }


    console.log(result);

    return result;
},

var result = convertData(data);

L'écriture n'est pas bonne. S'il existe une meilleure méthode, j'espère la partager

.