java使用递归将list转树结构

业务场景：对于使用父Id关联，可以无限增加层级的数据库表的设计，后端从数据库查出来的数据一般是List结构，实际业务上前台需要返回树状结构，那么就需要后端对数据进行加工。实现一般通过两种方式，递归或循环。

递归：递归的设计重点在于递归方法的返回值及参数。返回值可以采用包含自身List的一个类，方法的参数为父Id及数据源。

数据库表对应类：

package com.sinnet.inspire.organization.dao.entity.base;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * 组织表
 *
 * @author guoj
 * @date 2020/4/23 10:25
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrgOrganizationEntity {

    /**
     * 组织id
     */
    private String orgOrganizationId;
    /**
     * 组织名称
     */
    private String organizationName;
    /**
     * 父组织id
     */
    private String parentId;
    /**
     * 是否spn，1：是
     */
    private String spnIdentify;
    /**
     * 组织详情
     */
    private String orgOrganizationDetail;
    /**
     *
     */
    private String state;
    /**
     *
     */
    private Date createDate;
    /**
     *
     */
    private String createUser;


}

返回类，可以继承上面数据库表类，也可以直接使用json或map等数据类型：

package com.sinnet.inspire.organization.dao.entity.dto;

import com.sinnet.inspire.organization.dao.entity.base.OrgOrganizationEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

/**
 * 树形组织
 *
 * @author guoj
 * @date 2020/5/18 10:03
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrgTreeDto {

    private OrgOrganizationEntity orgOrganizationEntity;

    private List<OrgTreeDto> orgTreeDtoList;
}

递归实现：由于数据库的设计，数据并没有唯一的根组织，即最上层可能是平行的多个根组织，所以增加了的父id为null的判断。当传入的组织id为null，则将数据源中的父id为空的多条数据当作根。

package com.sinnet.inspire.organization.dao.service.org.impl;

import com.sinnet.devops.common.util.Result;
import com.sinnet.inspire.organization.dao.entity.base.OrgOrganizationEntity;
import com.sinnet.inspire.organization.dao.entity.dto.OrgTreeDto;
import com.sinnet.inspire.organization.dao.service.base.OrgOrganizationService;
import com.sinnet.inspire.organization.dao.service.base.OrgOrganizationUserService;
import com.sinnet.inspire.organization.dao.service.org.OrgManageQueryService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author guoj
 * @date 2020/5/14 10:23
 */
@Service
public class OrgManageQueryServiceImpl implements OrgManageQueryService {

    private static final Logger LOGGER = LoggerFactory.getLogger(OrgManageQueryServiceImpl.class);

    @Autowired
    private OrgOrganizationService orgOrganizationService;

    @Override
    public Map<String, Object> queryOrgTree(String spnOrgId) {
//数据源
        List<OrgOrganizationEntity> orgOrganizationEntityList = orgOrganizationService.getOrgOrganizationListByEntity(null);
        OrgTreeDto orgTreeDto = getOrgTree(spnOrgId, orgOrganizationEntityList);
        return Result.ok().put(orgTreeDto);
    }

    /**
     * 递归取组织树
     *
     * @param spnOrgId
     * @param orgOrganizationEntityList
     * @return
     */
    private OrgTreeDto getOrgTree(String spnOrgId, List<OrgOrganizationEntity> orgOrganizationEntityList) {
        OrgTreeDto orgTreeDto = getOrgTreeDtoByOrgId(spnOrgId, orgOrganizationEntityList);
        List<OrgOrganizationEntity> childOrgList = getChildOrgListByParentId(spnOrgId, orgOrganizationEntityList);
        List<OrgTreeDto> orgTreeDtoList = new ArrayList<>();
        if (childOrgList != null || childOrgList.size() > 0) {
            for (OrgOrganizationEntity orgOrganizationEntity : childOrgList) {
                //递归
                orgTreeDtoList.add(getOrgTree(orgOrganizationEntity.getOrgOrganizationId(), orgOrganizationEntityList));
            }
        }
        orgTreeDto.setOrgTreeDtoList(orgTreeDtoList);
        return orgTreeDto;
    }

    private List<OrgOrganizationEntity> getChildOrgListByParentId(String parentOrgId, List<OrgOrganizationEntity> orgOrganizationEntityList) {
        if (orgOrganizationEntityList == null || orgOrganizationEntityList.size() <= 0) {
            return null;
        }
        List<OrgOrganizationEntity> orgOrganizationEntityListNew = new ArrayList<>();
        for (OrgOrganizationEntity orgOrganizationEntity : orgOrganizationEntityList) {
            if (parentOrgId == null && orgOrganizationEntity.getParentId() == null) {
                orgOrganizationEntityListNew.add(orgOrganizationEntity);
            } else if (parentOrgId != null && parentOrgId.equals(orgOrganizationEntity.getParentId())) {
                orgOrganizationEntityListNew.add(orgOrganizationEntity);
            }
        }
        return orgOrganizationEntityListNew;
    }

    private OrgTreeDto getOrgTreeDtoByOrgId(String orgId, List<OrgOrganizationEntity> orgOrganizationEntityList) {
        OrgTreeDto orgTreeDto = new OrgTreeDto();
        if (orgId == null || orgOrganizationEntityList == null) {
            return orgTreeDto;
        }
        for (OrgOrganizationEntity orgOrganizationEntity : orgOrganizationEntityList) {
            if (orgId.equals(orgOrganizationEntity.getOrgOrganizationId())) {
                orgTreeDto.setOrgOrganizationEntity(orgOrganizationEntity);
                break;
            }
        }
        return orgTreeDto;
    }
}