Java 类目树形结构查询

最新推荐文章于 2023-11-07 14:10:25 发布
最新推荐文章于 2023-11-07 14:10:25 发布
阅读量2.2k 收藏 18
点赞数 1
分类专栏： 基础框架 文章标签： mybatis 查询类目树形结构 List转树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37583655/article/details/117518611
版权

Java 类目树形结构查询

1. 初始化数据库

1.1 类目表初始化

-- -------------------------------------
-- 类目测试 Table structure for category
-- -------------------------------------
DROP TABLE IF EXISTS `category`;
CREATE TABLE `category`  (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID主键',
  `name` varchar(64) COMMENT '名称',
  `pid` bigint(20) NOT NULL COMMENT '上级id',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '类目' ROW_FORMAT = Dynamic;

select * from category;
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (1, '电子产品', 0);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (2, '手机', 1);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (3, '小米手机', 2);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (4, '苹果手机', 2);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (5, '电脑', 1);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (6, '联想电脑', 5);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (7, '戴尔电脑', 5);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (8, '家用电器', 0);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (9, '空调', 8);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (10, '美的空调', 9);
INSERT INTO `category`.`category`(`id`, `name`, `pid`) VALUES (11, '格力空调', 9);

2. 构建项目

2.1 项目结构

在这里插入图片描述

2.2 代码文件

CategoryController

package com.example.category.controller;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;
import com.example.category.service.CategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;
import com.example.category.entity.Response;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.Resource;

import static org.apache.ibatis.ognl.DynamicSubscript.all;

/**
 * (Category)控制层
 *
 * @author makejava
 * @since 2021-06-03 07:20:41
 */
@RestController
@RequestMapping("/category")
public class CategoryController {
    /**
     * 服务对象
     */
    @Resource
    private CategoryService categoryService;

    /**
     * 通过主键查询单条数据
     *
     * @param category 参数对象
     * @return 单条数据
     */
    @RequestMapping(value = "get", method = RequestMethod.GET)
    public Response<Category> selectOne(Category category) {
        Category result = categoryService.selectById(category.getId());
        if (result != null) {
            return Response.createSuccessResponse("查询成功", result);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 新增一条数据
     *
     * @param category 实体类
     * @return Response对象
     */
    @RequestMapping(value = "insert", method = RequestMethod.POST)
    public Response<Category> insert(@RequestBody Category category) {
        int result = categoryService.insert(category);
        if (result > 0) {
            return Response.createSuccessResponse("新增成功", category);
        }
        return Response.createErrorResponse("新增失败");
    }

    /**
     * 修改一条数据
     *
     * @param category 实体类
     * @return Response对象
     */
    @RequestMapping(value = "update", method = RequestMethod.PUT)
    public Response<Category> update(@RequestBody Category category) {
        Category result = categoryService.update(category);
        if (result != null) {
            return Response.createSuccessResponse("修改成功", result);
        }
        return Response.createErrorResponse("修改失败");
    }

    /**
     * 删除一条数据
     *
     * @param category 参数对象
     * @return Response对象
     */
    @RequestMapping(value = "delete", method = RequestMethod.DELETE)
    public Response<Category> delete(Category category) {
        int result = categoryService.deleteById(category.getId());
        if (result > 0) {
            return Response.createSuccessResponse("删除成功", null);
        }
        return Response.createErrorResponse("删除失败");
    }

    /**
     * 查询全部
     *
     * @return Response对象
     */
    @RequestMapping(value = "selectAll", method = RequestMethod.GET)
    public Response<List<Category>> selectAll() {
        List<Category> categorys = categoryService.selectAll();
        if (categorys != null) {
            return Response.createSuccessResponse("查询成功", categorys);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 查询树形结构
     *
     * @return Response对象
     */
    @RequestMapping(value = "selectTree", method = RequestMethod.GET)
    public Response<List<CategoryVo>> selectTree() {
        List<CategoryVo> categoryVoList = categoryService.selectTree();
        if (categoryVoList != null) {
            return Response.createSuccessResponse("查询成功", categoryVoList);
        }
        return Response.createErrorResponse("查询失败");
    }

    /**
     * 分页查询
     *
     * @param start 偏移
     * @param limit 条数
     * @return Response对象
     */
    @RequestMapping(value = "selectPage", method = RequestMethod.GET)
    public Response<List<Category>> selectPage(Integer start, Integer limit) {
        List<Category> categorys = categoryService.selectPage(start, limit);
        if (categorys != null) {
            return Response.createSuccessResponse("查询成功", categorys);
        }
        return Response.createErrorResponse("查询失败");
    }

}

Category

package com.example.category.entity;

import java.io.Serializable;

/**
 * (Category)实体类
 *
 * @author makejava
 * @since 2021-06-03 07:20:41
 */
public class Category implements Serializable {
    private static final long serialVersionUID = 404235573904070855L;
    /**
    * 主键ID
    */
    private Integer id;
    /**
    * 名称
    */
    private String name;
    /**
    * 上级id
    */
    private Integer pid;

    public Category() {
    }

    public Category(Integer id, String name, Integer pid) {
        this.id = id;
        this.name = name;
        this.pid = pid;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    @Override
    public String toString(){
        return "Category {" +
            "id : " + id + ", " +
            "name : " + name + ", " +
            "pid : " + pid + ", " +
        '}';
    }
}

CategoryVo

package com.example.category.entity;

import java.util.List;

/**
 * @author zrj
 * @date 2021/6/3
 * @since V1.0
 **/
public class CategoryVo {

    /**
     * 主键ID
     */
    private Integer id;
    /**
     * 名称
     */
    private String name;
    /**
     * 上级id
     */
    private Integer pid;

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

    public CategoryVo() {
    }

    public CategoryVo(Integer id, String name, Integer pid, List<CategoryVo> children) {
        this.id = id;
        this.name = name;
        this.pid = pid;
        this.children = children;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public List<CategoryVo> getChildren() {
        return children;
    }

    public void setChildren(List<CategoryVo> children) {
        this.children = children;
    }

    @Override
    public String toString() {
        return "CategoryVo{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pid=" + pid +
                ", children=" + children +
                '}';
    }
}

Response

package com.example.category.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author zrj
 * @date 2021/6/2
 * @since V1.0
 **/
@Component
public class Response<T> {

    private static ResponseCode responseCode;
    /**
     * 提示消息
     */
    private String message;

    /**
     * 具体返回的数据
     */
    private T data;

    /**
     * 状态码
     */
    private String code;

    private Response(String code, String message, T data) {
        this.message = message;
        this.code = code;
        this.data = data;
    }

    private Response(String code, String msg) {
        this.message = msg;
        this.code = code;
    }

    @Autowired
    public Response(ResponseCode responseCode) {
        Response.responseCode = responseCode;
    }

    /**
     * 返回成功Response对象
     *
     * @param successMessage 成功提示信息
     * @param data           需要返回的数据
     * @return 成功信息
     */
    public static <T> Response<T> createSuccessResponse(String successMessage, T data) {
        return new Response<>( responseCode.getSuccessCode(), successMessage, data );
    }


    /**
     * 返回错误Response对象
     *
     * @param errorMessage 错误信息
     * @return 错误信息
     */
    public static <T> Response<T> createErrorResponse(String errorMessage) {
        return new Response<>( responseCode.getErrorCode(), errorMessage );
    }

    public Response() {
    }

    /**
     * 返回未登录状态码
     *
     * @param message 提示信息
     * @return Response
     */
    public static <T> Response<T> createUnLoginResponse(String message) {
        return new Response<>( responseCode.getAuthErrorCode(), message );
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

}

ResponseCode

package com.example.category.entity;

import org.springframework.stereotype.Component;

/**
 * @author zrj
 * @date 2021/6/2
 * @since V1.0
 **/
@Component
public class ResponseCode {
    private String successCode = "200";

    private String errorCode = "500";

    private String authErrorCode = "300";

    public String getSuccessCode() {
        return successCode;
    }

    public void setSuccessCode(String successCode) {
        this.successCode = successCode;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public String getAuthErrorCode() {
        return authErrorCode;
    }

    public void setAuthErrorCode(String authErrorCode) {
        this.authErrorCode = authErrorCode;
    }
}

CategoryService

package com.example.category.service;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;

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

/**
 * (Category)表服务接口
 *
 * @author makejava
 * @since 2021-06-03 07:20:43
 */
public interface CategoryService {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Category selectById(Integer id);

    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<Category> selectPage(int start, int limit);

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<Category> selectAll();

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<CategoryVo> selectTree();
    
    /**
     * 通过实体作为筛选条件查询
     *
     * @param category 实例对象
     * @return 对象列表
     */
    List<Category> selectList(Category category);

    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int insert(Category category);
	
	/**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 影响行数
     */
	int batchInsert(List<Category> categorys);
	
    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 修改
     */
    Category update(Category category);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 影响行数
     */
    int deleteById(Integer id);
    
    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    int count();
}

CategoryServiceImpl

package com.example.category.service.impl;

import com.example.category.entity.Category;
import com.example.category.entity.CategoryVo;
import com.example.category.mapper.CategoryMapper;
import com.example.category.service.CategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * (Category表)服务实现类
 *
 * @author makejava
 * @since 2021-06-03 07:20:44
 */
@Service("categoryService")
public class CategoryServiceImpl implements CategoryService {
    @Resource
    private CategoryMapper categoryMapper;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    public Category selectById(Integer id) {
        return this.categoryMapper.selectById(id);
    }

    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    @Override
    public List<Category> selectPage(int start, int limit) {
        return this.categoryMapper.selectPage(start, limit);
    }

    /**
     * 查询所有
     *
     * @return 实例对象的集合
     */
     @Override
     public List<Category> selectAll() {
        return this.categoryMapper.selectAll();
     }

    @Override
    public List<CategoryVo> selectTree() {
         // 查询全部数据
        List<Category> categoryList = categoryMapper.selectAll();

        // categoryList转换为categoryVoList
        List<CategoryVo> categoryVoList = categoryList.stream().map(category -> {
            CategoryVo categoryVo = new CategoryVo();
            BeanUtils.copyProperties(category, categoryVo);
            return categoryVo;
        }).collect(Collectors.toList());

        //获取得所有parentId为0的数据，也就是一级目录
        //用于封装数据，取得他的孩子（也就是下级目录）的数据
        List<CategoryVo> categoryVoTree = categoryVoList.stream()
                .filter(categoryVo -> categoryVo.getPid().equals(0))
                .map((categoryVoParent) -> {
                    categoryVoParent.setChildren(getChildrenData(categoryVoParent, categoryVoList));
                    return categoryVoParent;
                }).collect(Collectors.toList());

        return categoryVoTree;
    }

    /**
     * 获取孩子（下级目录）的方法，递归实现
     */
    private List<CategoryVo> getChildrenData(CategoryVo root, List<CategoryVo> all) {
        List<CategoryVo> children = all.stream().filter(categoryVo ->
                categoryVo.getPid().equals(root.getId())
        ).map(categoryVo -> {
            categoryVo.setChildren(getChildrenData(categoryVo, all));
            return categoryVo;
        }).collect(Collectors.toList());
        return children;
    }

    /**
     * 根据条件查询
     *
     * @return 实例对象的集合
     */
    @Override
    public List<Category> selectList(Category category) {
        return this.categoryMapper.selectList(category);
    }
    
    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 实例对象
     */
    @Override
    public int insert(Category category) {
        return this.categoryMapper.insert(category);
    }

    /**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 生效的条数
     */
    @Override
    public int batchInsert(List<Category> categorys) {
        return this.categoryMapper.batchInsert(categorys);
    }

    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 实例对象
     */
    @Override
    public Category update(Category category) {
        this.categoryMapper.update(category);
        return this.selectById(category.getId());
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    @Override
    public int deleteById(Integer id) {
        return this.categoryMapper.deleteById(id);
    }
    
    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
     @Override
     public int count(){
        return this.categoryMapper.count();
     }
}

CategoryMapper

package com.example.category.mapper;

import com.example.category.entity.Category;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;

/**
 * (Category)表数据库访问层
 *
 * @author makejava
 * @since 2021-06-03 07:22:32
 */
public interface CategoryMapper {

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    Category selectById(Integer id);
	
    /**
     * 分页查询
     *
     * @param start 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
    List<Category> selectPage(@Param("start") int start, @Param("limit") int limit);

    /**
     * 查询全部
     *
     * @return 对象列表
     */
    List<Category> selectAll();
    
    /**
     * 通过实体作为筛选条件查询
     *
     * @param category 实例对象
     * @return 对象列表
     */
    List<Category> selectList(Category category);

    /**
     * 新增数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int insert(Category category);
	
	/**
     * 批量新增
     *
     * @param categorys 实例对象的集合
     * @return 影响行数
     */
	int batchInsert(List<Category> categorys);
	
    /**
     * 修改数据
     *
     * @param category 实例对象
     * @return 影响行数
     */
    int update(Category category);

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 影响行数
     */
    int deleteById(Integer id);

    /**
     * 查询总数据数
     *
     * @return 数据总数
     */
    int count();
}

CategoryMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.category.mapper.CategoryMapper">
    <!-- 结果集 -->
    <resultMap type="com.example.category.entity.Category" id="CategoryMap">
        <result property="id" column="id" jdbcType="INTEGER"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="pid" column="pid" jdbcType="INTEGER"/>
    </resultMap>
    
    <!-- 基本字段 -->
    <sql id="Base_Column_List">
        id, name, pid    </sql>
    
    <!-- 查询单个 -->
    <select id="selectById" resultMap="CategoryMap">
        select
          <include refid="Base_Column_List" />
        from category
        where id = #{id}
    </select>

    <!-- 分页查询 -->
    <select id="selectPage" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
        limit #{start},#{limit}
    </select>

    <!-- 查询全部 -->
    <select id="selectAll" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
    </select>

    <!--通过实体作为筛选条件查询-->
    <select id="selectList" resultMap="CategoryMap">
        select
        <include refid="Base_Column_List" />
        from category
        <where>
                    <if test="id != null">
                and id = #{id}
            </if>
                    <if test="name != null and name != ''">
                and name = #{name}
            </if>
                    <if test="pid != null">
                and pid = #{pid}
            </if>
                </where>
    </select>

    <!-- 新增所有列 -->
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        insert into category(id, name, pid)
        values ( #{id}, #{name}, #{pid})
    </insert>
    
    <!-- 批量新增 -->
    <insert id="batchInsert">
        insert into category(id, name, pid)
        values 
        <foreach collection="categorys" item="item" index="index" separator=",">
        (
                        #{item.id},             #{item.name},             #{item.pid}         )
         </foreach>
    </insert>

    <!-- 通过主键修改数据 -->
    <update id="update">
        update category.category
        <set>
                    <if test="name != null and name != ''">
                name = #{name},
            </if>
                    <if test="pid != null">
                pid = #{pid},
            </if>
                </set>
        where id = #{id}
    </update>

    <!--通过主键删除-->
    <delete id="deleteById">
        delete from category where id = #{id}
    </delete>
    
    <!-- 总数 -->
    <select id="count" resultType="int">
        select count(*) from category
    </select>
</mapper>

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

server:
  port: 8080

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/category?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  type-aliases-package: com.example.category

#showSql
logging:
  level:
    com:
      example:
        mapper : debug

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>category</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>category</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3. 运行结果

在这里插入图片描述
GitHub地址：查询类目菜单树(https://github.com/zrj-coder/category)

靖节先生
关注
专栏目录
java树形结构递归查询
09-04
//组装类目为树结构 assembleTree(categoryTreeDTO, allDTOList,Constants.CATEGORY_MAX_LEVEL - level); } return categoryTree; } /** * 组装树 * * @param categoryTreeDTO * @param allList ...
Java常用写法-类目树的生成与遍历
lyk1184919379的博客
05-28 268
类目树的基本操作
java树结构查询及分页
weixin_45326523的博客
06-26 2625
树结构查询
代码笔记2：java实现多层主题树结构查询
qq_37398465的博客
11-28 1927
实现网站中常见的多层主题树结构查询。其数据结构是一个多层的树形结构，父主题包含一个子主题的列表，每一个子主题又包含下一级子主题的列表。通过一个接口查询所有的主题。
java Tree 树状结构递归搜索算法；过滤保留父节点
qq_42420773的博客
03-09 5904
初始树 /** * * 1 * / | \ * 2 3 4 * / \ /\ * 5 6 7 8 ...
java树形结构数据搜索
程序猿的博客
04-20 1738
public static List<TreeNode> search(List<TreeNode> data, String text) { List<TreeNode> res = new ArrayList<>(); for (TreeNode treeNode : data) { List<TreeNode> children = treeNode.getChildren()...
关系数据库存储树形结构数据的理想实践
02-24
针对不同的树形结构数据，如企业组织结构、行政区域划分、商品类目等级体系以及文件分类资料归档授权体系等，每种树形结构数据都有其特定的应用场景和特点。在设计存储方案时，需要根据实际业务需求来选择合适的树形...
淘宝类目查询工具 宝贝类目一键查询软件 天猫分类查询
01-16
淘宝类目查询工具是一款专为电商从业者设计的实用软件，主要功能是帮助用户快速、准确地查询淘宝和天猫平台上的商品所属类别。在电子商务日益发达的今天，了解正确的商品类目对于商家至关重要，因为它直接影响到商品...
MySQL多层级结构-区域表使用树详解
12-16
1. **nested set model**：这是一种用于存储树结构数据的方法，通过左值和右值两个字段，可以快速定位节点的位置和它的子节点集合。左值小于等于一个节点的左值并且大于等于该节点的右值的所有节点都是这个节点的子...
SQL Server 通过with as方法查询树型结构
09-09
这样，即使存在循环引用的树结构，查询也不会无休止地执行下去。 总结来说，`WITH AS`在SQL Server中提供了强大的功能，尤其是处理树型结构数据时。非递归CTE可以简化复杂查询，而递归CTE则能有效地遍历层次结构。...
java实现二叉搜索树功能
老男孩的架构路
08-03 331
第四种，也就是之前说的有点复杂，比如要删除C节点，将F节点的父节点设置成A节点，F节点左节点设置成E节点，将A的右节点设置成F，E的父节点设置F节点(也就是将F节点替换C节点)，还有一种，直接将E节点替换C节点。二叉搜索树也成二叉排序树，它有这么一个特点，某个节点，若其有两个子节点，则一定满足，左子节点值一定小于该节点值，右子节点值一定大于该节点值，对于非基本类型的比较，可以实现Comparator接口，在本文中为了方便，采用了int类型数据进行操作。3、要删除的节点只有右子节点，如F节点。...
树形结构的数据库表Schema设计
热门推荐
愤怒的小狐狸----博客专栏
07-30 9万+
树形结构的数据库表Schema设计：一种基于左、右值编码前序遍历的树形结构数据库表Schema设计方案，消除了频繁的“递归”操作，提升了树形结构查询效率~
Java实现树形结构和递归查询
最新发布
Spirit_NKlaus的专栏
11-07 554
树形结构的数据一般是利用类似于id和parent_id之前的关系来构造，以部门为例，当前部门的信息中需要知道自己的部门编号和上一级的部门编号，才能构造出树形结构的数据，先准备好能够构造树形结构的数据。部门的基础实体和部门树实体。编写一个测试类运行查看效果。
Java 树型查找
lijieaace的博客
04-14 701
java sql 树型查找
java搜索树形结构数据,叶子节点并一起带父子节点数据返回
Oscrazy的博客
08-19 2066
java搜索树形结构数据,叶子节点并一起带父子节点数据返回
树形结构数据根据ID查找name
Machangzhi_1115的博客
04-22 746
let tree = [ { id: 0, name: "0", children: [ { id: 01, name: "01", children: [ { id: 011, name: "011", children: [] } ] }, { id:
[Java 实现三级类目树 demo ]
汤圆的博客
05-31 942
撒树成林
Java树形结构查询（Steam）
xiaoxiaohan130的博客
10-22 6223
大部门场景需要展示树形结构的数据，目的是一目了然能够看明白数据，特别是对于组织或者一些企业以及部门 下面给大家讲一下我写树形结构时候的一个思路 1、了解树形结构是如何形成的：因为树形结构肯定是有父级和子级，这样才能够关联起来 2、在我的了解范围内，有两种，一种是无限层级，子级和父级在一张表里面，第二分别在两张表里面，需要关联查询 1.1那么我们第一步要做的就是先把最外层的节点构造出来，然后依次往子级里面放相关的数据 1、可以在实体里面 声明一个集合 2、拿到数据之后，先把最外层节...
java实现树形查询
ljh981124的博客
06-01 2699
首先这个树形查询，你肯定不能用他内置sql语句吧，所以这里我们自己在dao层写一句sql语句进行查询： @Query(value = "select * from TB_UIM_MENU_TEST t START WITH t.PID IS NULL" + " CONNECT BY PRIOR t.ID = t.PID order by t.PID NULLS first,t.MENU_SORT ASC",nativeQuery = true) List<MenuTestDTO>
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值