java循环遍历树状结构对象并转换成另外树状结构对象

项目工程需要调用外部服务接口返回树状结构对象，不能直接使用，需要再次转换处理，满足实际的项目需求，涉及到两点处理：
1、遍历树状对象

//外部服务对象
public class DepartmentVO {

    private Integer id;
    private Integer orgId;
    private String code;
    private String name;
    private String nameZh;
    private Integer parentId;
    private String parentIds;
    private DepartmentStatus status;
    private DepartmentType type;
    private Integer ownerId;
    private Integer rank;
//    private Instant createdAt;
//    private Instant updatedAt;
    private Integer createdBy;
    private Integer updatedBy;
    private String userCode;
    private String username;
    private List<DepartmentVO> subDepartments;

}


//需要使用的树状结构对象
public class McmpDepartmentDto implements Serializable {

  @ApiModelProperty(value = "部门ID", example = "0")
  private Integer id;
  @ApiModelProperty(value = "租户ID", example = "0")
  private Integer orgId;
  @ApiModelProperty(value = "部门编码")
  private String code;
  @ApiModelProperty(value = "部门英文名称")
  private String name;
  @ApiModelProperty(value = "部门中文名称")
  private String nameZh;
  @ApiModelProperty(value = "父级ID")
  private Integer parentId;
  @ApiModelProperty(value = "父级（路径）")
  private String parentIds;
  @ApiModelProperty(value = "级别（1,2,3,4....）")
  private String level;
  private List<McmpDepartmentDto> subDepartments = new ArrayList<>();
  public void addChild(McmpDepartmentDto child) {
    subDepartments.add(child);
  }

  /**
   * 查找指定ID的节点，并返回该节点及其所有子节点的ID集合
   * @param root 树的根节点
   * @param targetId 目标节点的ID
   * @return 包含目标节点及其所有子节点ID的集合
   */
  public static Set<Integer> findNodeAndDescendants(DepartmentVO root, Integer targetId) {
    Set<Integer> ids = new HashSet<>();
    searchNodeAndCollectIds(root, targetId, ids);
    return ids;
  }

  private static void searchNodeAndCollectIds(DepartmentVO node, Integer targetId, Set<Integer> ids) {
    if (node.getId().equals(targetId)) {
      ids.add(node.getId());
      collectChildIds(node, ids);
    } else {
      for (DepartmentVO child : node.getSubDepartments()) {
        searchNodeAndCollectIds(child, targetId, ids);
      }
    }
  }

  private static void collectChildIds(DepartmentVO node, Set<Integer> ids) {
    ids.add(node.getId());
    for (DepartmentVO child : node.getSubDepartments()) {
      collectChildIds(child, ids);
    }
  }

//调用地方
public List<McmpDepartmentDto> searchDepartmentTree(Long tenantId){
        List<McmpDepartmentDto> mcmpDepartmentDtos = new ArrayList<>();
        DepartmentSearchForm departmentSearchForm = new DepartmentSearchForm();
        departmentSearchForm.setOrgId(tenantId.intValue());
        //外部服务返回的集合对象，里面对象就是树状结构
        List<DepartmentVO> result =  iamDepartmentClient.searchTree(departmentSearchForm).getData();
        if(!CollectionUtils.isEmpty(result)){
            for(DepartmentVO departmentVO :result){
                mcmpDepartmentDtos.add(traverseTreeRecursive(departmentVO));
            }
        }
        return mcmpDepartmentDtos;
    }


    public McmpDepartmentDto traverseTreeRecursive(DepartmentVO departmentVO) {

        if (departmentVO == null) {
            return null;
        }
        McmpDepartmentDto mcmpDepartmentDto = new McmpDepartmentDto();
        BeanUtils.copyProperties(departmentVO,mcmpDepartmentDto);
        mcmpDepartmentDto.setLevel(getLevel(mcmpDepartmentDto.getParentIds()));
        // 遍历子节点
        for (DepartmentVO child : departmentVO.getSubDepartments()) {
            mcmpDepartmentDto.addChild(traverseTreeRecursive(child));
        }
        return mcmpDepartmentDto;
    }

    /**
     * 通过当前所属父级的路径信息，返回当前节点所属于的Level层级
     * @param parentIds
     * 举例：最顶级阶段 parentIds=null 表示一级； parentIds=/34959/ 表示二级 ； parentIds=/34959/35079/ 表示三级，
     * @return
     */
    public String getLevel(String parentIds){
        if(null==parentIds || parentIds.equals("")){
            return "1";
        }
        return String.valueOf(countCharUsingRegex(parentIds,"/"));
    }

    /**
     * 字符串中出现某个特殊符号的次数
     * @param str
     * @param regex
     * @return
     */
    public static int countCharUsingRegex(String str, String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        return count;
    }