精华内容
下载资源
问答
  • Java递归将List转为结构 博客地址:https://blog.csdn.net/weixin_38500202/article/details/110456363
  • public static List listToTree(List list) { //用递归找子。 List treeList = new ArrayList(); for (AccountCaptionVo tree : list) { //根目录的parentId为-1 if (tree.getParentId() == -1 ) { treeList.add...

    @Data

    @EqualsAndHashCode(callSuper =true)

    @ApiModel(value = "AccountCaptionVo", description = "会计科目")

    public class AccountCaptionVo extends BaseModel {

    @ApiModelProperty(value ="会计科目名称",name = "captionName")

    private String captionName;

    @ApiModelProperty(value = "会计科目编码",name = "captionCode")

    private String captionCode;

    @ApiModelProperty(value = "父类编码",name = "parentId")

    private Long parentId;

    @ApiModelProperty(value = "系统科目",name = "systematicSubjects")

    private String systematicSubjects;

    @ApiModelProperty(value = "借贷方向",name = "lendingDirection")

    private String lendingDirection;

    @ApiModelProperty(value = "子集",name = "children")

    private List children;

    @ApiModelProperty(value = "科目名称助记码",name = "mnemonicCode")

    private String mnemonicCode;

    public static List listToTree(List list) {

    //用递归找子。

    List treeList = new ArrayList();

    for (AccountCaptionVo tree : list) {

    //根目录的parentId为-1

    if (tree.getParentId() == -1 ) {

    treeList.add(findChildren(tree, list));

    }

    }

    return treeList;

    }

    private static AccountCaptionVo findChildren(AccountCaptionVo tree, List list) {

    for (AccountCaptionVo node : list) {

    if (node.getParentId().longValue() == tree.getId().longValue()) {

    if (tree.getChildren() == null) {

    tree.setChildren(new ArrayList());

    }

    tree.getChildren().add(findChildren(node, list));

    }

    }

    return tree;

    }

    @GetMapping(path="")

    @ApiOperation(value="获取所有会计科目",nickname="getAccountCaption")

    public Iterable List(){

    List listAccountCaption= capAccountRepository.selecttSql();

    List listAccountCaptionVos=new ArrayList<>();

    listAccountCaption.stream().forEach(x->

    {

    AccountCaptionVo AccountCaptionVo=new AccountCaptionVo();

    try {

    BeanUtils.copyProperties(AccountCaptionVo,x);

    listAccountCaptionVos.add(AccountCaptionVo);

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    } catch (InvocationTargetException e) {

    e.printStackTrace();

    }

    });

    return listToTree(listAccountCaptionVos);

    }

    展开全文
  • java 递归生成树结构

    千次阅读 2018-12-20 17:19:21
    package com.lsn.ams; import com.alibaba.fastjson.JSONArray... import java.util.*; import java.util.ArrayList; import java.util.LinkedHashMap;...import java.util.List; import java.util.Map; public class...
    package com.lsn.ams;
    
    import com.alibaba.fastjson.JSONArray;
    import java.util.*;
    import java.util.ArrayList;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    
    public class Test {
    
    
        public static void main(String[] args) {
            List<Tree> data = new ArrayList<Tree>();
    
            Tree tree = new Tree();
            tree.setId("1");
            tree.setPid("0");
            tree.setName("系统管理");
    
            data.add(tree);
    
            tree = new Tree();
    
            tree.setId("2");
            tree.setPid("1");
            tree.setName("管理员列表");
            data.add(tree);
    
            tree = new Tree();
            tree.setId("3");
            tree.setPid("2");
            tree.setName("新增管理员");
            data.add(tree);
    
            tree = new Tree();
            tree.setPid("0");
            tree.setId("4");
            tree.setName("导览管理");
            data.add(tree);
    
            tree = new Tree();
            tree.setId("5");
            tree.setPid("4");
            tree.setName("POI管理");
            data.add(tree);
    
    
            MenuTree menuTree = new MenuTree();
            List<Object> list = menuTree.menuList(data);
    
            System.out.println(JSONArray.toJSON(list));
    
        }
    
    
    }
    
    
    /**
     *
     * 递归类
     */
    class MenuTree {
    
        public static Map<String, Object> mapArray = new LinkedHashMap<String, Object>();
        public List<Tree> menuCommon;
        public List<Object> list = new ArrayList<Object>();
    
        public List<Object> menuList(List<Tree> menu) {
    
            this.menuCommon = menu;
            for (Tree x : menu) {
    
                Map<String, Object> mapArr = new LinkedHashMap<String, Object>();
                if (x.getPid() == "0") {
                    mapArr.put("id", x.getId());
                    mapArr.put("name", x.getName());
                    mapArr.put("pid", x.getPid());
                    mapArr.put("childList", menuChild(x.getId()));
                    list.add(mapArr);
                }
            }
    
    
            return list;
        }
    
        public List<?> menuChild(String id) {
            List<Object> lists = new ArrayList<Object>();
            for (Tree a : menuCommon) {
                Map<String, Object> childArray = new LinkedHashMap<String, Object>();
                if (a.getPid() == id) {
                    childArray.put("id", a.getId());
                    childArray.put("name", a.getName());
                    childArray.put("pid", a.getPid());
                    childArray.put("childList", menuChild(a.getId()));
                    lists.add(childArray);
                }
            }
    
            return lists;
        }
    
    }
    
    /**
     * 树实体类
     */
    class Tree {
    
        private String id;
        private String pid;
        private String name;
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getPid() {
            return pid;
        }
    
        public void setPid(String pId) {
            this.pid = pId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Tree [id=" + id + ", pid=" + pid + ", name=" + name + "]";
        }
    
    }
    展开全文
  • 业务场景:对于使用父Id关联,可以无限增加层级的数据库表的设计,后端从数据库查出来的数据一般是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;
        }
    }
    

     

    展开全文
  • java代码生成: 实体类: public class CompanyInfo { private Long id; /* * 父级企业编码 * */ private String parentCode; /** * 子节点 */ private List<CompanyInfo> childList; } ...

    java代码生成:

    实体类:
    public class CompanyInfo {
    
    	private Long id;
    	
    
    	/*
    	* 父级企业编码
    	* */
    	private String parentCode;
    
    	/**
    	 * 子节点
    	 */
    	private List<CompanyInfo> childList;
    	
     }
    
    service中:
    public static List<CompanyInfo> listToTree(List<CompanyInfo> list) {
        //用递归找子。
        List<CompanyInfo> treeList = new ArrayList<CompanyInfo>();
        for (CompanyInfo tree : list) {
       //如果根目录的parentId为-1
            if (tree.getParentId() == -1 ) {
                treeList.add(findChildren(tree, list));
            }
        }
        return treeList;
    }
    
    private static CompanyInfo findChildren(CompanyInfo tree, List<CompanyInfo> list) {
        for (CompanyInfo node : list) {
            if (node.getParentId().longValue() == tree.getId().longValue()) {
                if (tree.getChildren() == null) {
                    tree.setChildren(new ArrayList<CompanyInfo>());
                }
                tree.getChildren().add(findChildren(node, list));
            }
        }
        return tree;
    }
    

    mybatis生成:

    实体类
    public class CompanyInfo {
    
    	private Long id;
    	
    
    	/*
    	* 父级企业编码
    	* */
    	private String parentCode;
    
    	/**
    	 * 子节点
    	 */
    	private List<CompanyInfo> childList;
    	
     }
    
    mapper.java中:
    List<CompanyInfo> getCompanyTreeByGroupCode(@Param("parentCode") String parentCode);
    
    mapper.xml
    <resultMap id="BaseTreeResultMap" type="com.xxx.CompanyInfo">
    		<id column="id_" property="id" jdbcType="BIGINT" />
    		<result column="parent_code" property="parentCode" jdbcType="VARCHAR" />
    		<collection column="company_code" property="childList" javaType="java.util.ArrayList"
    					ofType="com.xxx.CompanyInfo" select="getNextNodeTree"/>
    	</resultMap>
    
    	<select id="getNextNodeTree" resultMap="BaseTreeResultMap">
            SELECT
            *
            FROM com_company
            WHERE parent_code = #{parentCode} AND enable_ = 1
        </select>
    
    	<select id="getCompanyTreeByGroupCode" resultMap="BaseTreeResultMap">
            SELECT
            *
            FROM com_company
            WHERE company_code = #{parentCode} AND enable_ = 1
        </select>
    
    展开全文
  • java递归生成树结构菜单

    万次阅读 多人点赞 2019-01-04 16:59:01
    } 四、从数据库获取菜单数据,调用组装菜单函数生成树结构的数据 public static void main(String[] args) { List list = new ArrayList (); //TODO 这里从数据库获取全量菜单后放到list中 //树形结构数据...
  • java递归生成树结构(类似菜单)

    千次阅读 2019-07-19 17:17:45
    下面是java代码生成这样的的json代码 这里不包括展现,展现很简单 /*** * pid 父id * allList 所有数据库查出来的list数据 */ public List<Map<String,Object>> getChild(String pid , List<...
  • Java递归将List转为结构

    千次阅读 2020-12-01 23:33:00
    文章目录 目录 文章目录 ...使用递归来获取子节点,在递归的过程中将已添加到树结构中的数据剔除,减少递归调用的次数 2.实现 代码下载链接: Menu内部类定义如下 @Data static class ..
  • java递归生成树结构

    千次阅读 2020-04-24 15:29:58
    项目开发中,几乎无法...前端处理树形结构,后端生成树结构。 Entity实体层: 此处省略好几个实体字段。 /** * 孩子节点集合 */ private List<OrganizationVO> child = new ArrayList<Organiza...
  • 在项目开发过程中,需要对存在关联的数据库表中的数据以结构在页面上进行展示,通过SQL语句难以进行处理,需要在程序的业务层进行处理。 1、数据表 ① city_groups表 说明: city_groups表通过id 和 parent_id...
  • java递归将list转为tree树结构 实体类 public class Main { private String id; private String name; private String pid; private List<Main> children; public String getId() { return i...
  • java 递归 生成树

    千次阅读 2018-01-11 16:48:46
    此方法可以表中的所有全部生成 先说好,写得不好别怪我,不过还是可以生成的。 我的想法是,数据库中存的不一定是一棵,也就是说最顶级的父节点不止一个。 那就好办了: 1 先读取数据库中的所有数据存放...
  • Java递归生成树

    2019-11-19 16:06:01
    这里只展示递归生成树的代码,查询数据库的操作非常简单,只用到了一句sql,然后结果封装成List。 select id , pid , `name` from t_menu service代码: @Override public List < Menu > tree ( ...
  • @param rootList 根结点* @param listAll 所有结点* @param parentId 父子集依赖关系* @param spread有子结点是否展开* true 展开* false 不展开* @return 结构的字符串*/public String getTreeByStack(List>...
  • java递归生成树结构数据,以查询省、市、区树形结构为例 service层代码 @Autowired private AreaDao dao; /** * 获取省、市、区树形结构数据 */ public void getTree(int id) { Area area = dao....
  • public class Ttt {public String tree(List ret, String rootId, String p) {StringBuffer retList = new StringBuffer();for (Map m : ret) {if (rootId.equals(m.get("PARENTID"))) {retList.append(p+m.get("NAM...
  • 2.生成树实体对象 3.递归实现树结构封装 package com.jd.org.service.impl; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.jd.org.entity.TreeNode; import ...
  • Java 无限级递归生成树级菜单

    千次阅读 2019-04-10 21:15:19
    有做过网站菜单的童鞋,都知道结构,因为展开的形式就是一棵一样,有父节点、子节点。实现结构菜单的形式有很多,例如主从表的形式,一张表存父节点,一张表存子节点,这种方式可能存在一种问题,就是只能...
  • list原始数据 [ {name:"A一级菜单1",fid:"-1",id:"1"}, {name:"AA二级菜单1",fid:"1",id:"2"}, {name:"AAA三级菜单1",fid:"2",id:"3"}, {name:"AB二级菜单2",fid:"1",id:"4"}, {name:"B一级菜单2",fid:"-1",id:"5"},...
  • list集合递归生成树

    2019-11-19 23:30:18
    list集合递归生成树 @Test public void test1(){ List<JsTree> all = jsTreeDao.getAll(); try { List<JsTree> resourceTree = getResourceTree( all, "0" ); System....
  • 递归生成树结构

    万次阅读 多人点赞 2018-06-22 13:41:56
    TreeNode实体类 key-菜单id title-菜单名称 parentId-父子菜单id cildren-子...import java.util.List; /** * @Author forewei * @date 2018-6-13 17:04 */ public class TreeNode { private Integer key; ...
  • java递归生成树

    千次阅读 2017-10-05 10:47:41
    public List getAllCommType(){  List treeList=new ArrayList();  //取到父节点id为0,只有一个  List typeList=commType.getAllCommodityType();  for(Commodity_type type :typeList){  Tree tree=new...
  • 递归生成一个如图的菜单,编写两个类数据模型Menu、和创建形的MenuTree。通过以下过程实现: 1.首先从菜单数据中获取所有根节点。   2.为根节点建立次级子树并拼接上。 3.递归为子节点建立次级子树并接上,直至为...
  • 实际上,我们也可以理解为如何拥有父子关系的list转成结构,而这其中主要的方法就是递归! 1、实体对象: @Data public class Node { private Integer id; private String city; private Integer pid; ...
  • java递归生成json

    千次阅读 2018-03-21 15:43:13
    1、准备表结构及对应的表数据a、表结构:create table TB_TREE ( CID NUMBER not null, CNAME VARCHAR2(50), PID NUMBER //父节点 )b、表数据:insert into tb_tree (CID, CNAME, PID) values (1, '中国', 0); ...
  • JAVA递归生成树形菜单 递归生成一个如图的菜单,编写两个类数据模型Menu.和创建树形的MenuTree.通过以下过程实现: 1.首先从菜单数据中获取所有根节点. 2.为根节点建立次级子树并拼接上. 3.递归为子节点建立次级 ... ...
  • java后端,iview前端,代码后半段有controller使用参考 ... import lombok.Data;...import java.util.List; /** * 节点工具类 * @author SWJ * */ @Data public class TreeNode...
  • [1、准备表结构及对应的表数据a、表结构:create table TB_TREE(CID NUMBER not ... 递归查询tree结构有两种做法:第一种,递归查询数据库结构,第二种,一次性数据库表中的所有数据查出来,然后再递归查出来的l...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,674
精华内容 8,669
关键字:

java将list递归生成树结构

java 订阅