使用Map对树形结构数据进行封装

使用Map进行数据结果可以快速高效的进行树形结构的创建，避免了多次重复的递归操作。
有序的结果集只需要一次即可构建树形结构数据
无序的结果集可以使用Comparable接口的compareTo方法进行排序

package com.gumj.rbac.domain.vo;

import lombok.Data;

import java.util.List;

/**
 * @author : gumingjun
 * @date : 2021-01-15
 */
@Data
public class OrgTreeVO {
    /**
     * 组织ID
     */
    private Long id;
    /**
     * 组织父ID
     */
    private Long pid;

    /**
     * 组织名称
     */
    private String name;

    /**
     * 组织简称
     */
    private String shortName;

    /**
     * 组织类型
     */
    private Integer type;

    /**
     * 层级编码
     */
    private String levelCode;

    /**
     * 是否叶子节点
     */
    private Boolean leaf;

    /**
     * 排序号
     */
    private Integer sortNo;

    /**
     * 子节点
     */
    private List<OrgTreeVO> children;

    /**
     * 给父节点添加子节点
     *
     * @param child  子节点
     */
    /*
    public void addChild(OrgTreeVO child) {
    	if (children == null) {
    		children = new ArrayList<>();
    	}
    	children.add(child);
    }*/
}

/**
 * 组织机构转换接口
 *
 * @author : gumingjun
 * @date : 2021-01-15
 */
@Mapper
public interface OrganizationStructMapper {

    OrganizationStructMapper INSTANCE = Mappers.getMapper(OrganizationStructMapper.class);

    /**
     * 组织机构对象转换组织机构树对象
     *
     * @param organization 组织机构对象
     * @return 组织机构树对象
     */
    OrgTreeVO toOrgTreeVO(Organization organization);
}

/**
 * 给父节点添加子节点
 *
 * @param parent 父节点
 * @param child  子节点
 */
private void addChild(OrgTreeVO parent, OrgTreeVO child) {
    List<OrgTreeVO> children;
    if ((children = parent.getChildren()) == null) {
        children = new ArrayList<>();
    }
    children.add(child);
    parent.setChildren(children);
}

/**
 * 业务常量类
 *
 * @author : gumingjun
 * @date : 2021-01-04
 */
public class BusinessConst {
    /**
     * 树形结构默认根节点ID
     */
    public static final Long ROOT_ID = 0L;
    /**
     * 树形结构默认根节点层级编码
     */
    public static final String ROOT_LEVEL_CODE = "000";
    /**
     * 层级编码段长度
     */
    public static final Integer LEVEL_CODE_SEGMENT_LENGTH = 3;
}

有序结果集处理

//TODO 如果要求同层级节点有序排序，则需要对同层级的节点进行排序处理
public List<OrgTreeVO> listTreeOrganization() {
	//树集合
	List<OrgTreeVO> vos = new ArrayList<>();
	//返回的是有序集合
	final List<Organization> organizations = baseMapper.listAllOrganization();
	Map<Long, OrgTreeVO> treeMap = new HashMap<>(organizations.size());
	
	organizations.forEach(e -> {
		//实体对象转VO对象
	    final OrgTreeVO node = organizationStructMapper.toOrgTreeVO(e);
	    //添加子节点
	    OrgTreeVO parent;
	    if ((parent = treeMap.get(e.getPid())) != null) {
	        addChild(parent, node);
	    }
	    treeMap.put(e.getId(), node);
	    
	    //添加根节点到集合
	    if (BusinessConst.ROOT_ID.equals(e.getPid())) {
	        vos.add(node);
	    }
	});
	return vos;
}

无序结果集处理

public List<OrgTreeVO> listTreeOrganization2() {
	//树集合
    List<OrgTreeVO> vos = new ArrayList<>();
	//返回的是无序集合
    final List<Organization> organizations = baseMapper.listAllOrganization();
	
	//实体对象转VO对象
    final Map<Long, OrgTreeVO> orgMap = organizations.parallelStream().collect(Collectors.toMap(Organization::getId, e -> organizationStructMapper.toOrgTreeVO(e)));
    orgMap.forEach((k, v) -> {
    	//添加子节点
        OrgTreeVO parent;
        if ((parent = orgMap.get(v.getPid())) != null) {
            addChild(parent, v);
        }
        
	    //添加根节点到集合
        if (BusinessConst.ROOT_ID.equals(v.getPid())) {
            vos.add(v);
        }
    });
    return vos;
}