当前位置：网站首页>Several cases of recursive processing organization

Several cases of recursive processing organization

2022-07-03 00:59:00 【It snows at night when the boat is moored, and he can expect it】

Recursively handle several cases of organization

Preface

A little summary of recent work , Record here .

Recursive encapsulation tree structure organization

/**
  *  Tree structure encapsulation 
  *
  * @param root
  * @param all
  * @return
  */
 private List<OrgVO> getChildren(OrgVO root, List<OrgVO> all) {
    
  return all.stream().filter(orgVO ->
   root.getId().equals(orgVO.getParentId())).map(orgVO -> {
    
   orgVO.setChildrenEntity(getChildren(orgVO, all));
   return orgVO;
  }).sorted(Comparator.comparingInt(c -> (c.getSort() == null ? 0 : c.getSort()))).collect(Collectors.toList());
 }

Recursively obtain descendants

/**
     *  Recursively obtain descendants 
     * @param orgCode
     * @return
     */
    private List<Org> getAllChildren(String orgCode){
    
        List<Org> allChildren = new ArrayList<>();
        List<Org> orgListByParent = OrgService.getOrgListByParent(orgCode);
        //  Judge here  size  Greater than  1  The reason is that  getOrgListByParent()  Method if the descendant institution is not obtained, the current institution information is returned 
        if (CollectionUtils.isNotEmpty(orgListByParent) && orgListByParent.size() > 1){
    
            allChildren.addAll(orgListByParent);
            for (Org org : orgListByParent) {
    
                List<Org> children = getAllChildren(organization.getOrgCode());
                allChildren.addAll(children);
            }
        }
        return allChildren;
    }

Recursively accumulate the number of descendants

 /**
     *  Recursive statistics current + Number of descendants , And return to the current department and sub level 
     * @param root
     * @param data
     * @return
     */
    private List<UserDTO> getUserNum(UserDTO root, List<UserDTO> data){
    
        Integer userCount = root.getUserCount();
        data.forEach(dto -> {
    
            if (root.getOrgCode().equals(dto.getParentCode())){
    
                root.setUserCount(userCount+dto.getUserCount());
                List<UserDTO> collect = data.stream().filter(dto1 -> dto1.getParentCode().equals(dto.getOrgCode())).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(collect)){
    
                    getUserNum(dto,collect);
                }

            }
        });
        List<UserDTO> collect = data.stream().filter(userDTO -> userDTO.getParentCode().equals(root.getOrgCode())).collect(Collectors.toList());
        root.userCount(collect.stream().map(UserDTO::getUserCount).mapToInt(Integer::intValue).sum()+userCount);
        collect.add(0,root);
      return collect;

    }