如何在Java中以特定方式对JSON列编号排序

我在Spring Boot中开发了一个应用程序。用户可以上载CSV文件，其中包含数字和代码列。在Java代码中，我能够得到number列

CSV文件

number   code
12
121
122
123
1211
1212
1231
124

我的目标和回应是：

回应-目标

json: [{ number: 12, 
    child: [{number: 121, 
       child: [{number: 1211 }, { number: 1212 }]
    }] 
}, {number: 122 },
   {number: 123, child:[{number: 1231}] }.....etc
]

如何在Java中按父级和子级排列JSON结构？例如，12是121的父项，121是1211和1212的父项

更新：

输入值：

12
121
122
123
1211
1212
1231
14
141
142
1411
25
251
2511
2512
252
253

响应输出

    response: [
   {
      "number": 12,
      "child": [
         {
            "number": 121,
            "child": [
               {
                  "number": 1211
               },
               {
                  "number": 1212
               }
            ]
         },
         [
            {
               "number": 122
            }
         ],
         [
            {
               "number": 123,
               "child": [
                  {
                     "number": 1231
                  }
               ]
            }
         ]
      ]
   },
   {
      "number": 14,
      "child": [
         {
            "number": 141,
            "child": [
               {
                  "number": 1411
               }
            ]
         },
         [
            {
               "number": 142
            }
         ]
      ]
   },
   {
      "number": 25,
      "child": [
         {
            "number": 251,
            "child": [
               {
                  "number": 2511
               },
               {
                  "number": 2512
               }
            ]
         },
         [
            {
               "number": 252
            }
         ],
         [
            {
               "number": 253
            }
         ]
      ]
   }
]

---

创建一个具有两个字段的响应对象

public class Response() {

  public int number;

  public List<Response> children;

}

公共类响应（）{
公共整数；
公开儿童名单；
}

---

这个类会给你你想要的。

这不是真正的Java或JSON问题。简而言之，您的问题是-如何在知道列表元素之间的祖先-后代关系的情况下，将值列表组装到树结构中

我提出的算法是：

选择一个元素并检查它是否是其中一个根的后代。 如果不是，则将其添加到根列表中。检查是否存在任何问题 根实际上是该元素的后代，并将其指定为 如果它们是（例如，如果我们的输入中有12个，那么我们有1个 应该移动12成为1的孩子-尽管这可能不完全是 在这种特定情况下，如果我们的输入已排序，则需要，例如，1将 总是在12点之前到123点之前等）。注：由于输入的排序，此部分是可选的，但如果使用未排序的输入，则有点不完整（如果wee的12后跟1234，然后是123，则不会产生正确的结果-1234和123都将是12的子项，但这不正确-1234应成为123的子项，而不是直接成为12的子项）。这将是你完成它的家庭作业；-）

如果它是某个人的后代 根-查找根的子级，它也可能是根的后代。如果 没有这样的-将其指定为直接子级。如果有,， 将其视为潜在的父母，但也要检查其子女 对于潜在的父对象，等等

下面是一个完整的工作解决方案，可以按照您的预期生成JSON：

package tmpjavaproj;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class Test {

    public static class Node implements Comparable<Node> {
        public int number;
        public List<Node> child; // Although this should actually be called children, not child

        public int hashCode() {
            return number;
        }

        public boolean equals(Node node) {
            return number == node.number;
        }

        public int compareTo(Node node) {
            return number - node.number;
        }
    }

    public static void main(String[] args) throws Exception {
        String[] inputs = { "12", "121", "122", "123", "1211", "1212", "1231", "14", "141", "142", "1411", "25", "251", "2511", "2512", "252", "253" };

        Set<Node> roots = new TreeSet<>();

        for (String input : inputs) {
            Node node = new Node();
            node.number = Integer.parseInt(input);

            Node root = null;
            for (Node rootCandidate : roots) {
                if (input.startsWith(String.valueOf(rootCandidate.number))) {
                    root = rootCandidate;
                    break;
                }
            }
            if (root == null) {
                List<Node> rootsToChildren = new ArrayList<>();
                for (Node aRoot : roots) {
                    if (String.valueOf(aRoot.number).startsWith(String.valueOf(node.number))) {
                        rootsToChildren.add(aRoot);
                    }
                }
                if (!rootsToChildren.isEmpty()) {
                    node.child = rootsToChildren;
                    roots.removeAll(rootsToChildren);
                }
                roots.add(node);
            } else {
                Node parentCandidate = root;
                while (root != null) {
                    root = null;
                    if (parentCandidate.child != null) {
                        for (Node child : parentCandidate.child) {
                            if (input.startsWith(String.valueOf(child.number))) {
                                parentCandidate = child;
                                root = child;
                            }
                        }
                    }
                }
                if (parentCandidate.child == null) {
                    parentCandidate.child = new ArrayList<>();
                }
                parentCandidate.child.add(node);
            }
        }

        Map<String, Set<Node>> response = new HashMap<>();
        response.put("response", roots);
        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        mapper.setSerializationInclusion(Include.NON_NULL);
        System.out.println(mapper.writeValueAsString(response));
    }
}

包tmpjavaproj；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
导入java.util.TreeSet；
导入com.fasterxml.jackson.annotation.JsonInclude.Include；
导入com.fasterxml.jackson.databind.ObjectMapper；
导入com.fasterxml.jackson.databind.SerializationFeature；
公开课考试{
公共静态类节点实现了可比较的{
公共整数；
public List child；//虽然这实际上应该称为children，而不是child
公共int hashCode（）{
返回号码；
}
公共布尔等于（节点）{
返回编号==node.number；
}
公共整数比较（节点）{
返回编号-node.number；
}
}
公共静态void main（字符串[]args）引发异常{
字符串[]输入={“12”、“121”、“122”、“123”、“1211”、“1212”、“1231”、“14”、“141”、“142”、“1411”、“25”、“251”、“2511”、“2512”、“252”、“253”}；
设置根=新树集（）；
for（字符串输入：输入）{
节点=新节点（）；
node.number=Integer.parseInt（输入）；
节点根=空；
用于（节点根候选：根）{
if（input.startsWith（String.valueOf（rootCandidate.number）））{
根=根候选；
打破
}
}
if（root==null）{
List rootsToChildren=new ArrayList（）；
for（节点aRoot:根）{
if（String.valueOf（aRoot.number）.startsWith（String.valueOf（node.number）））{
rootsToChildren.add（aRoot）；
}
}
如果（！rootsToChildren.isEmpty（））{
node.child=rootsToChildren；
根。removeAll（rootsToChildren）；
}
根。添加（节点）；
}否则{
节点parentCandidate=root；
while（root！=null）{
root=null；
if（parentCandidate.child！=null）{
对于（节点子节点：parentCandidate.child）{
if（input.startsWith（String.valueOf（child.number）））{
父母候选人=子女；
根=子；
}
}
}
}
if（parentCandidate.child==null）{
parentCandidate.child=new ArrayList（）；
}
parentCandidate.child.add（节点）；
}
}
Map response=newhashmap（）；
response.put（“response”，词根）；
ObjectMapper mapper=新的ObjectMapper（）；
enable（SerializationFeature.INDENT_输出）；
mapper.setSerializationInclusion（Include.NON_NULL）；
System.out.println（mapper.writeValueAsString（response））；
}
}

我不明白您是如何创建输出的。你能解释一下吗？@PaulErlenmeyer，谢谢你的重播，我的输出是json，创建json并输入值，在此之前我需要找到从数字中排序父项和子项的方法，我编辑了你的帖子，希望能澄清你的意思。如果不合适，请告诉我。我不确定这个

JSON

响应是什么样子。父映射看起来像：

{12=[121122123124]，121=[1211212]，122=[]，123=[1231]，124=[]，1211=[]，1212=[]，1231=[]}

。如果

121

在

12

的

child

数组中，那么为什么

122

不是而是与

12

在同一级别上存在呢。另一方面，为什么

121

与

12

不出现在同一级别？@MichałZiober，感谢您的重播，是的，我需要此类型：

{12=[121，1]