HashMap<Integer,List<Integer>> map=new HashMap<>(); public List<List<Integer>> levelOrder(TreeNode root) { Integer i=0; return map.values(); }这段代码 错误

<think>好的，用户的问题是关于如何将SQL查询结果在Java中整理成树形结构。首先，我需要仔细分析用户提供的SQL代码，理解其结构和目的。 这段SQL使用了公用表表达式（CTE），特别是递归的BOMHierarchy，用来展开某个父部件（superid='2000003069'）的所有子部件层级，同时检测循环。输出结果包括ParentID、ParentVersion、ChildID、Level和Path。用户希望将这些平铺的数据转换为树形结构，方便在Java中处理。 接下来，我需要考虑如何将这种层级数据转换为树形结构。通常，树形结构需要节点类，包含当前节点的信息和子节点列表。因此，首先应该定义一个TreeNode类，包含id、version、子节点列表等字段。 然后，处理数据的方式通常有两种：递归和迭代。由于数据已经按Level排序，可能更适合使用迭代的方法，逐层构建树。或者，可以利用Map来存储每个节点的引用，通过ChildID和ParentID的关系来建立连接。 需要注意的是，可能存在多个层级，每个ChildID可能成为下一层的ParentID。因此，需要确保每个节点只创建一次，并且正确挂载到父节点下。 另外，用户提到的SQL结果中，Path字段可能有助于检测循环，但在构建树时可能不需要处理循环，因为查询中已经通过IsCycle='N'过滤了循环路径。不过，可能需要考虑是否需要在Java中进行额外的循环检测，但根据SQL的逻辑，已经排除了循环，所以可能不需要处理。 接下来，考虑代码的具体实现。首先，从数据库获取结果集，遍历每一行，创建或获取对应的节点。使用一个Map来存储所有已创建的节点，键为节点的ID。对于每一行，检查ParentID是否存在，如果存在，则将当前ChildID对应的节点添加到父节点的子节点列表中。如果ParentID不存在于Map中，可能需要创建父节点，但根据查询的逻辑，根节点是已知的（superid='2000003069'），所以根节点应该首先被处理。 可能的步骤是： 1. 定义TreeNode类。 2. 遍历查询结果，将每行数据转换为TreeNode对象，并存储在Map中。 3. 对于每个节点，找到其父节点，并将自己添加到父节点的子节点列表。 4. 最后，根节点即为树形结构的起点。 需要注意处理顺序，因为子节点可能在父节点之后被处理，所以需要确保父节点先被创建。或者，在遍历时，每次处理一行时，先创建或获取父节点，再处理子节点。 此外，需要考虑同一个ChildID可能出现在多个层级，但根据SQL的逻辑，每个ChildID在某个父节点下只会出现一次，因为使用了MAX版本和递归中的IsCycle检查。因此，每个节点在Map中应该唯一。 现在，可能需要考虑如何处理根节点。在SQL中，根节点的ParentID是2000003069，但根据查询的初始部分，根节点的superid是2000003069，而ParentID在BOMHierarchy的UNION ALL第一部分中被设置为superid，即2000003069，而ChildID是它的子部件。因此，根节点实际上是ParentID为2000003069，而它的子节点是ChildID。所以，根节点需要被单独创建，然后逐层添加子节点。 或者，可能根节点是ParentID为2000003069，而每个记录中的ParentID对应一个节点，ChildID是其子节点。因此，根节点是ParentID=2000003069，而它的子节点是ChildID。然后，每个ChildID可能又作为ParentID出现在后续的行中。 因此，处理时，需要将所有ParentID和ChildID都视为节点，并建立父子关系。 可能的实现步骤： 1. 遍历所有记录，收集所有唯一的节点ID，包括ParentID和ChildID，创建TreeNode对象，并存入Map。 2. 再次遍历记录，对于每行，获取ParentID对应的节点，然后将ChildID对应的节点添加为其子节点。 3. 最后，根节点是ParentID='2000003069'的节点。 但是，这种方法需要两次遍历。或者，可以在一次遍历中处理：对于每一行，确保ParentID和ChildID的节点都存在，然后建立父子关系。 例如： - 当处理一行时，检查ParentID是否存在，如果不存在，则创建父节点并存入Map。 - 检查ChildID是否存在，如果不存在，则创建子节点并存入Map。 - 将子节点添加到父节点的子节点列表中。 这样，所有节点都会被处理，并且父子关系建立起来。 但需要注意，ParentID可能在后来的行中出现作为ChildID，所以必须确保在处理时，父节点已经被创建或者会被后续处理。不过，因为数据是按Level排序的，根节点会首先处理，然后依次处理子节点，所以可能可以保证父节点已经存在。 根据SQL中的ORDER BY Level, ParentID，结果集是按层级和ParentID排序的，这意味着根节点的记录会先出现，然后是子节点。因此，在遍历时，父节点应该已经被创建，因此在处理子节点时，父节点已经存在于Map中。 因此，具体的代码步骤可能是： 1. 定义TreeNode类。 2. 创建Map<String, TreeNode> nodesMap，用于存储所有节点。 3. 创建根节点（ParentID='2000003069'），并加入Map。 4. 遍历结果集的每一行： a. 获取当前行的ParentID, ChildID。 b. 检查ParentID是否在nodesMap中，如果不在，创建并加入。 c. 检查ChildID是否在nodesMap中，如果不在，创建并加入。 d. 将Child节点添加到Parent节点的children列表中。 5. 最后，根节点即为nodesMap中的ParentID='2000003069'的节点。 但是，需要确认在结果集中，根节点的ParentID是否是2000003069，而它的父节点是否存在？根据SQL的初始查询部分，根节点是WHERE b.superid = ‘2000003069’，所以第一层的ParentID是2000003069，ChildID是它的直接子节点。在递归部分，后续的ParentID是上一层的ChildID。因此，所有记录的ParentID都是存在的，因为递归是通过INNER JOIN BOMHierarchy bh ON b.superid = bh.ChildID，所以父节点已经存在于之前的层级中。 因此，在遍历结果集时，按照Level排序，父节点一定已经处理过了，因此在处理当前行时，ParentID对应的节点一定已经在Map中。 这样，代码可以安全地处理每一行，无需担心父节点不存在的情况。 现在，具体到Java代码的实现： 首先，定义TreeNode类： public class TreeNode { private String id; private String version; private List<TreeNode> children = new ArrayList<>(); // 构造方法、getter、setter } 然后，处理结果集： 假设有一个List<BomRecord> resultList，其中BomRecord是包含ParentID、ParentVersion、ChildID、Level、Path的DTO。 在遍历时： Map<String, TreeNode> nodesMap = new HashMap<>(); TreeNode root = null; for (BomRecord record : resultList) { String parentId = record.getParentID(); String childId = record.getChildID(); String parentVersion = record.getParentVersion(); // 处理父节点 TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); // 如果是根节点 if (parentId.equals("2000003069")) { root = parentNode; } } // 处理子节点 TreeNode childNode = nodesMap.get(childId); if (childNode == null) { childNode = new TreeNode(childId, record.getParentVersion()); // 这里可能需要确认Child的version是否是ParentVersion，或者是否有其他字段？ nodesMap.put(childId, childNode); } // 添加子节点到父节点的children中，避免重复添加 if (!parentNode.getChildren().contains(childNode)) { parentNode.getChildren().add(childNode); } } 这里可能存在一个问题：ChildID的version是否正确？因为BomRecord中的ParentVersion是对应ParentID的版本，而ChildID作为子节点，它自己的版本可能需要从它的记录中获取。但根据SQL结构，每个ChildID在作为ParentID时，会使用其MAX(superver)。因此，可能需要为每个节点存储自己的版本信息。 但在这个结果集中，每条记录的ParentID和ParentVersion是该记录的父部件的版本，而ChildID的子部件在其作为父部件时，会有自己的ParentVersion。因此，可能在创建ChildNode时，应该记录的是ChildID作为父部件时的版本，但当前记录中并没有提供ChildID的版本，除非在表中parttopart中，当ChildID作为superid时，其superver是该ChildID的版本。 不过，根据查询结果，每条记录的ParentVersion是当前行的superid的max版本，而ChildID是subid，它可能在其他行中作为superid出现，此时它的ParentVersion会是该subid的max版本。 因此，在创建节点时，可能需要为每个节点存储它自己的版本，即当该节点作为superid时的max版本。但根据当前结果集的结构，每条记录的ParentVersion是superid的max版本，而ChildID的版本可能需要在其作为superid时的记录中获取。 但这里可能存在数据不一致，因为ChildID的版本只有在它作为superid时才会出现在ParentVersion字段中。因此，在结果集中，当处理ChildID作为父节点时，其ParentVersion字段才会是它的版本。 因此，在创建节点时，可能需要为每个节点记录其版本，当该节点作为ParentID时，使用对应的ParentVersion，而当它作为ChildID时，可能没有版本信息，除非它在后续的行中作为ParentID出现。 这可能会导致问题，因为当ChildID从未作为ParentID出现时，它的版本信息将无法获取。但根据数据库设计，可能每个部件在作为父部件时都会有记录，因此每个ChildID如果存在于树中，必然会在某个时候作为ParentID出现，从而获取其版本。 因此，在代码中处理时，当处理某条记录时，ChildID可能还没有版本信息，直到该ChildID作为ParentID出现在后续记录中时，才会设置其版本。 因此，在创建ChildNode时，可能需要先创建节点，但版本可能暂时为null，直到处理到该节点作为ParentID的记录时，才能设置版本。 因此，代码需要处理这种情况： 在遍历记录时，对于每个ParentID，设置其version；对于ChildID，如果在后续记录中作为ParentID出现，则设置version，否则可能为null或保留默认。 但根据SQL的递归逻辑，只有当ChildID作为ParentID存在时，才会继续递归，因此每个ChildID如果存在于树中，必然会有作为ParentID的记录（除非它是叶子节点，即没有子节点）。但是，对于叶子节点，它作为ChildID时，可能没有对应的ParentID记录，因此其version无法设置。 这可能是一个问题。因此，需要确认在结果集中，每个节点的版本是否都能被正确捕获。 或者，可能结果集中的每条记录的ParentVersion对应的是该行ParentID的max版本，而ChildID的版本可能在其他行中作为ParentID的max版本出现。 例如，假设有一条记录：ParentID=A, ParentVersion=2, ChildID=B。当B作为ParentID出现在另一行时，ParentVersion会是B的max版本，比如3。 因此，当处理到ParentID=B的行时，会设置B的version为3。 因此，在代码中，处理顺序很重要。当处理到ParentID=A的行时，ChildID=B的节点被创建，此时version可能未被设置。当后续处理ParentID=B的行时，该节点的version会被更新为对应的ParentVersion。 因此，在代码中，处理每条记录时，应该同时更新ParentID的节点的version，并且当ChildID作为ParentID出现时，也会更新自己的version。 因此，修改代码逻辑： 在遍历每条记录时： - 处理ParentID：确保存在，并设置其version为当前记录的ParentVersion。 - 处理ChildID：确保存在，但此时ChildID的version可能还未设置，除非之前已经作为ParentID出现过。 因此，在代码中： for (BomRecord record : resultList) { String parentId = record.getParentID(); String parentVersion = record.getParentVersion(); String childId = record.getChildID(); // 处理父节点 TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); } else { // 更新父节点的版本，确保是最新的？或者根据SQL逻辑，每个ParentID的版本已经是MAX，所以只需设置一次？ // 由于SQL中已经GROUP BY superid并取MAX(superver)，所以每个ParentID的ParentVersion是唯一的，只需在首次创建时设置即可，后续无需更新。 // 因此，可能不需要在这里更新，因为ParentID对应的记录只会出现一次？或者可能多次出现？ // 需要分析SQL结果集的结构。 } // 处理子节点 TreeNode childNode = nodesMap.get(childId); if (childNode == null) { childNode = new TreeNode(childId, null); // 暂时没有版本信息 nodesMap.put(childId, childNode); } // 添加子节点到父节点的children列表 if (!parentNode.getChildren().contains(childNode)) { parentNode.getChildren().add(childNode); } } 但是，这里的问题在于，当ChildID作为ParentID出现在后续记录中时，它的version会被设置吗？ 例如，当处理ParentID=B的记录时，会创建或获取B节点，并设置其version为ParentVersion。因此，在后续处理中，当B作为ParentID出现时，它的version会被正确设置。 而如果ChildID从未作为ParentID出现（即叶子节点），则它的version将保持为null。但根据数据库设计，可能每个部件都有版本信息，即使它没有子部件。因此，可能需要从其他表中获取该信息，或者原查询结果是否包含每个节点的版本。 这里可能存在一个设计问题：原SQL查询只返回了ParentID的版本，而没有返回ChildID的版本，除非ChildID在其他行中作为ParentID出现。因此，叶子节点的version可能无法获取，除非在原始数据中有其他方式获取。 因此，可能需要调整SQL查询，以获取每个节点的版本信息，无论它是作为ParentID还是ChildID。或者，在Java代码中，假设每个节点的版本信息在其作为ParentID时才能获取，而叶子节点的版本无法获取，这可能需要进一步处理。 但根据用户提供的SQL，结果集中的ParentVersion是每个ParentID的最大版本，而ChildID的版本并未直接提供，除非ChildID在其他行中作为ParentID出现。因此，在树形结构中，非叶子节点的版本可以正确获取，而叶子节点的版本可能缺失。 这可能是一个问题，需要用户确认是否需要处理。但根据用户的问题描述，可能只需要将结构转换为树形，版本信息可能仅对父节点有效，或者用户可能接受叶子节点版本为null。 因此，在代码中，暂且按上述逻辑处理，叶子节点的version可能为null。 接下来，根节点是ParentID='2000003069'，在第一次处理时会被创建，并设置其version。因此，最终的根节点可以从nodesMap中获取。 综上，完整的Java代码可能如下： 定义TreeNode类： public class TreeNode { private String id; private String version; private List<TreeNode> children; public TreeNode(String id, String version) { this.id = id; this.version = version; this.children = new ArrayList<>(); } // getters and setters } 处理结果集： List<BomRecord> records = // 从数据库获取的结果集，假设BomRecord有getParentID(), getParentVersion(), getChildID()等方法 Map<String, TreeNode> nodesMap = new HashMap<>(); TreeNode root = null; for (BomRecord record : records) { String parentId = record.getParentID(); String parentVersion = record.getParentVersion(); String childId = record.getChildID(); // 处理父节点 TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); // 如果是根节点 if ("2000003069".equals(parentId)) { root = parentNode; } } else { // 由于ParentID在MaxVersion中已经取最大版本，此处无需更新version // 但如果存在多个ParentVersion的情况，可能需要处理，但根据SQL逻辑，每个ParentID只会出现一次 } // 处理子节点 TreeNode childNode = nodesMap.get(childId); if (childNode == null) { childNode = new TreeNode(childId, null); // 版本暂时为null nodesMap.put(childId, childNode); } // 添加子节点到父节点的children，避免重复 if (!parentNode.getChildren().contains(childNode)) { parentNode.getChildren().add(childNode); } } // 此时，根节点是nodesMap中的"2000003069" return root; 但需要注意，当处理到ChildID作为ParentID的记录时，该节点的version会被正确设置。例如，假设有一条记录ParentID=B，ParentVersion=3，ChildID=C。在处理该记录时，会创建B节点，并设置其version为3，而C节点被创建，version为null，直到C作为ParentID出现时才会设置。 因此，最终树中的每个非叶子节点的version是正确的，而叶子节点的version为null。如果用户需要叶子节点的version，可能需要调整SQL查询，或者在处理时从其他数据源获取。 但根据用户的问题，可能只需要结构，version可能不是关键。因此，上述代码可以满足结构转换的需求。 测试案例：假设结果集有两条记录： 1. ParentID=2000003069, ParentVersion=1, ChildID=A, Level=1 2. ParentID=A, ParentVersion=2, ChildID=B, Level=2 处理第一条记录时，创建父节点2000003069，version=1，子节点A，version=null。然后处理第二条记录，父节点A已存在（但version=null），此时会创建父节点A，但此时发现A已经存在，所以会覆盖？或者不会，因为nodesMap.get(parentId)会获取到已存在的节点，但version是null，此时是否需要更新？ 根据当前代码，父节点A在第一条记录中是作为ChildID被创建的，version为null。在第二条记录中，ParentID=A，此时会检查nodesMap中是否存在A，存在，所以不会重新创建，而是获取已存在的节点，但此时ParentVersion是2，而节点A的version仍然是null。因此，代码中存在一个问题：当处理ParentID=A的记录时，应该设置其version为2，但当前代码仅在创建节点时设置version，而后续处理中不会更新。 因此，需要修改代码，确保每次处理ParentID时，设置其version，即使节点已经存在。例如： 在处理父节点时，无论是否存在，都设置其version： TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); } else { // 更新版本信息 parentNode.setVersion(parentVersion); } 这样，当处理到ParentID=A的记录时，即使A节点已经存在（作为ChildID被创建），此时会更新其version为2。 这样，叶子节点B的version在作为ChildID时被创建为null，但如果后续没有作为ParentID出现，则保持null。否则，如果B作为ParentID出现，其version会被设置。 因此，修改代码： 在循环中： // 处理父节点 TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); } else { parentNode.setVersion(parentVersion); // 更新版本 } 这样，即使父节点之前作为ChildID被创建，此时会更新其version。 这样，上述测试案例中，节点A的version会在处理第二条记录时被设置为2。 因此，最终的代码需要包含在父节点存在时，更新其version。但需要考虑，是否可能同一个ParentID在多个记录中出现，导致多次设置version。例如，同一个ParentID可能有多个子节点，每次处理都会设置version，但由于SQL中已经按MAX(superver)分组，因此每个ParentID的ParentVersion是唯一的，多次设置也无妨。 因此，修改后的处理逻辑是正确的。 综上，最终的Java代码如下： 定义TreeNode类： public class TreeNode { private String id; private String version; private List<TreeNode> children; public TreeNode(String id, String version) { this.id = id; this.version = version; this.children = new ArrayList<>(); } // Getters and setters public String getId() { return id; } public void setId(String id) { this.id = id; } public String getVersion() { return version; } public void setVersion(String version) { this.version = version; } public List<TreeNode> getChildren() { return children; } public void setChildren(List<TreeNode> children) { this.children = children; } } 处理代码： public TreeNode buildTree(List<BomRecord> records) { Map<String, TreeNode> nodesMap = new HashMap<>(); TreeNode root = null; for (BomRecord record : records) { String parentId = record.getParentID(); String parentVersion = record.getParentVersion(); String childId = record.getChildID(); // 处理父节点 TreeNode parentNode = nodesMap.get(parentId); if (parentNode == null) { parentNode = new TreeNode(parentId, parentVersion); nodesMap.put(parentId, parentNode); // 检查是否是根节点 if ("2000003069".equals(parentId)) { root = parentNode; } } else { // 更新父节点的版本 parentNode.setVersion(parentVersion); } // 处理子节点 TreeNode childNode = nodesMap.get(childId); if (childNode == null) { childNode = new TreeNode(childId, null); // 初始version为null nodesMap.put(childId, childNode); } // 添加子节点到父节点，避免重复 if (!parentNode.getChildren().contains(childNode)) { parentNode.getChildren().add(childNode); } } return root; } 这样，根节点会被正确识别，并且每个节点的version会被正确设置，无论是作为父节点还是子节点。 可能的改进点： 1. 使用LinkedHashMap来保持插入顺序，但可能不影响。 2. 处理循环依赖，但根据SQL中的IsCycle='N'，结果集中已排除循环，因此无需处理。 3. 优化子节点添加的判断，使用Set来快速判断是否存在，但需要重写TreeNode的equals/hashCode方法，或者使用id进行比较。 例如，修改添加子节点的逻辑： if (parentNode.getChildren().stream().noneMatch(n -> n.getId().equals(childNode.getId()))) { parentNode.getChildren().add(childNode); } 这样可以避免重复添加。 总结，用户的问题是将具有层级关系的数据库查询结果转换为树形结构，关键点在于正确建立父子关系，并处理每个节点的版本信息。通过使用Map存储所有节点，并在遍历结果集时动态创建和更新节点，可以有效地构建树形结构。</think>以下是逐步解决方案及Java代码示例： ### 步骤分析 1. **数据结构定义**：创建树节点类`TreeNode`，包含ID、版本和子节点列表 2. **哈希表存储**：使用`Map<String, TreeNode>`快速定位已存在的节点 3. **双重节点处理**：同时处理每条记录中的父节点和子节点 4. **版本更新机制**：确保父节点版本始终为最新MAX值 5. **层级关系构建**：通过哈希表建立父子引用关系 6. **循环检测处理**：依赖SQL层已过滤循环数据（WHERE IsCycle='N'） ### 完整Java实现 ```java import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; // 树节点定义 class TreeNode { private String id; private String version; private List<TreeNode> children = new ArrayList<>(); public TreeNode(String id, String version) { this.id = id; this.version = version; } // Getters and Setters public String getId() { return id; } public String getVersion() { return version; } public void setVersion(String version) { this.version = version; } public List<TreeNode> getChildren() { return children; } } // 数据库记录映射类 class BomRecord { private String parentID; private String parentVersion; private String childID; public BomRecord(String parentID, String parentVersion, String childID) { this.parentID = parentID; this.parentVersion = parentVersion; this.childID = childID; } // Getters public String getParentID() { return parentID; } public String getParentVersion() { return parentVersion; } public String getChildID() { return childID; } } public class BomTreeBuilder { public TreeNode buildBomTree(List<BomRecord> records) { Map<String, TreeNode> nodeMap = new HashMap<>(); TreeNode root = null; for (BomRecord record : records) { // 处理父节点 TreeNode parent = nodeMap.computeIfAbsent( record.getParentID(), k -> new TreeNode(k, record.getParentVersion()) ); parent.setVersion(record.getParentVersion()); // 始终更新为最新版本 // 设置根节点（根据SQL中的初始条件） if (root == null && "2000003069".equals(record.getParentID())) { root = parent; } // 处理子节点 TreeNode child = nodeMap.computeIfAbsent( record.getChildID(), k -> new TreeNode(k, null) ); // 建立父子关系（防重复添加） if (parent.getChildren().stream() .noneMatch(n -> n.getId().equals(child.getId()))) { parent.getChildren().add(child); } } return root; } // 示例使用方法 public static void main(String[] args) { // 模拟数据库查询结果 List<BomRecord> records = new ArrayList<>(); records.add(new BomRecord("2000003069", "V1", "A001")); records.add(new BomRecord("A001", "V2", "B002")); records.add(new BomRecord("B002", "V3", "C003")); BomTreeBuilder builder = new BomTreeBuilder(); TreeNode root = builder.buildBomTree(records); // 此处可添加树形结构遍历验证代码 } } ``` ### 关键实现逻辑 1. **节点复用机制**：使用`Map.computeIfAbsent`确保每个部件ID只创建一个节点对象 2. **版本动态更新**：每次遇到父节点记录时更新其版本号，保证使用MAX版本 3. **层级关系验证**：通过`stream().noneMatch()`防止重复添加子节点 4. **根节点识别**：根据SQL中`WHERE superid='2000003069'`确定树根起点 ### 扩展优化建议 1. **添加循环检测**：虽然SQL层已过滤，可在Java层添加路径校验 2. **树形遍历方法**：添加深度优先/广度优先遍历实现 3. **JSON序列化**：添加`toString()`方法实现树形结构可视化 4. **版本空值处理**：对于叶子节点，可通过额外查询补全版本信息 该实现方案时间复杂度为$O(n)$，空间复杂度$O(n)$，适用于大规模BOM表数据处理。