如何在java中使用映射递归将数据分组简化为n次？

我想通过以下方式将一组组组返回到n次

[
{
“字段”：“TestContacts\u CompanyName”，
“值”：“MC 1”，
“hasSubgroups”：没错，
“项目”：[
{
“字段”：“TestContacts\u ID”，
“价值”：“25”，
“hasSubgroups”：false，
“项目”：[
{           
“TestContacts_ID”：“25”，
TestContacts_CompanyName:“MC 1”
}      
]
},                  
{
“字段”：“TestContacts\u ID”，
“价值”：“26”，
“hasSubgroups”：false，
“项目”：[
{
“TestContacts_ID”：“26”，
TestContacts_CompanyName:“MC 1”
}          
]
},
{
“字段”：“TestContacts\u ID”，
“价值”：“27”，
“hasSubgroups”：false，
“项目”：[
{
“TestContacts_ID”：“27”，
TestContacts_CompanyName:“MC 1”
}
]
}
]
},
{
“字段”：“TestContacts\u CompanyName”，
“值”：“MC 2”，
“hasSubgroups”：没错，
“项目”：[
{“字段”：“TestContacts_ID”，
“价值”：“28”，
“hasSubgroups”：false，
“项目”：[
{
“TestContacts_ID”：“28”，
“TestContacts_CompanyName”：“MC 2”
}
]
}
]
}
]    

我不想使用收集器。groupingby

public static JSONArray groupedArray(ArrayList<String> groupField,JSONArray itemsArray) throws Exception {
        JSONArray itemArrayTemp = new JSONArray();
        int i=0;
         
         for (Map.Entry<String,ArrayList<Object>> entry : SLQUtil.groupData(groupField.get(i),itemsArray).entrySet()) {
                JSONObject itemTemp = new JSONObject();
             
                 itemTemp.put("field",groupField.get(i) );
                 itemTemp.put("value",entry.getKey() );
                 
             if((groupField.size()-i ==1)){
                 itemTemp.put("hasSubgroups",false );//Single level grouping
                 itemTemp.put("items",entry.getValue() );
             }else if((groupField.size()-i > 1)){
                 itemTemp.put("hasSubgroups",true );//2nd level grouping
                 JSONArray jsArray2 = new JSONArray(entry.getValue());//converting array list to json array
                 JSONArray itemArrayTemp2 = new JSONArray();
                 for (Map.Entry<String,ArrayList<Object>> entry2 : SLQUtil.groupData(groupField.get(i+1),jsArray2).entrySet()) {
                        JSONObject itemTemp2 = new JSONObject();
                     itemTemp2.put("field",groupField.get(i+1));
                     itemTemp2.put("value",entry2.getKey() );
                         itemTemp2.put("hasSubgroups",false );
                         itemTemp2.put("items",entry2.getValue() );
                 
                     itemArrayTemp2.put(itemTemp2 );//2nd level of grouped data
                 }
                 itemTemp.put("items",itemArrayTemp2 );
             }
             itemArrayTemp.put(itemTemp);//1st level of grouped data
         }

       return itemArrayTemp;
    }


    public static Map<String, ArrayList<Object>> groupData(String field,JSONArray itemsArray) throws  Exception {

        Map<String, ArrayList<Object>> itemMap = new LinkedHashMap<>();
        for (int i=0;i<itemsArray.length();i++){
            JSONObject itemTemp = itemsArray.getJSONObject(i);
            
            if(!itemMap.containsKey(itemTemp.getString(field))){
              itemMap.put(itemTemp.getString(field), new ArrayList<>());
            }
            itemMap.get(itemTemp.getString(field)).add(itemTemp);
        }

       return itemMap;
    }

publicstaticjsonarray-groupedArray（ArrayList-groupField，JSONArray-itemsArray）抛出异常{
JSONArray itemArrayTemp=新的JSONArray（）；
int i=0；
for（Map.Entry:SLQUtil.groupData（groupField.get（i），itemsArray.entrySet（））{
JSONObject itemTemp=新的JSONObject（）；
itemTemp.put（“字段”，groupField.get（i））；
itemTemp.put（“value”，entry.getKey（））；
if（（groupField.size（）-i==1））{
itemTemp.put（“hasSubgroups”，false）；//单级分组
itemTemp.put（“items”，entry.getValue（））；
}else if（（groupField.size（）-i>1））{
itemTemp.put（“hasSubgroups”，true）；//第二级分组
JSONArray jsArray2=新的JSONArray（entry.getValue（））；//将数组列表转换为json数组
JSONArray itemArrayTemp2=新的JSONArray（）；
for（Map.Entry entry2:SLQUtil.groupData（groupField.get（i+1），jsArray2.entrySet（））{
JSONObject itemTemp2=新的JSONObject（）；
itemTemp2.put（“field”，groupField.get（i+1））；
itemTemp2.put（“value”，entry2.getKey（））；
itemTemp2.put（“hasSubgroups”，false）；
itemTemp2.put（“items”，entry2.getValue（））；
itemArrayTemp2.put（itemTemp2）；//分组数据的第二级
}
itemTemp.put（“项目”，itemArrayTemp2）；
}
itemArrayTemp.put（itemTemp）；//分组数据的第一级
}
返回itemArrayTemp；
}
公共静态映射groupData（字符串字段，JSONArray itemsArray）引发异常{
Map itemMap=newlinkedhashmap（）；
for（int i=0；i
publicstaticmap-groupDataRecursive（stringcurrentkey，Map-Map，Map-out）抛出SQLException，Exception{
对于（Map.Entry:Map.entrySet（））{
if（entry.getValue（）instanceof Map）{
groupDataRecursive（currentKey，（Map）entry.getValue（），out）；
}否则{
Map tempMap=SLQUtil.groupData（currentKey，（JSONArray）entry.getValue（））；
put（entry.getKey（），tempMap）；
//out.put（currentKey+“+entry.getKey（），entry.getValue（））；
}
}
返回图；
}

public static Map<String, Object> groupDataRecursive(String currentKey, Map<String, Object> map, Map<String, Object> out) throws SQLException, Exception {
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        if (entry.getValue() instanceof Map) {
            groupDataRecursive(currentKey, (Map<String, Object>) entry.getValue(), out);
        } else {
            Map tempMap = SLQUtil.groupData(currentKey,(JSONArray)entry.getValue());
            map.put( entry.getKey(),tempMap);
            //out.put(currentKey + "." + entry.getKey(), entry.getValue());
        }
    }
    return map;
}