# treeify-list-util

**Repository Path**: syusukezhang/treeify-list-util

## Basic Information

- **Project Name**: treeify-list-util
- **Description**: Java List 转换成树
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2020-12-04
- **Last Updated**: 2021-12-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 列表转换树的工具类

## maven dep
```xml
<dependency>
    <groupId>me.yuxiaoyao.util.treeify</groupId>
    <artifactId>treeify-list-util</artifactId>
    <version>1.0.0</version>
</dependency>
```

## compile
```
mvn clean compile package install
```

## usage

### API

```
/**
 * 转换成树的类(带深度) 默认起始深度为 0
 *
 * @param sourceList 来源列表
 * @param firstTest  
 * @param cls
 * @param test
 * @param <T>
 * @param <R>
 * @return
 */
public static <T, R extends ITreeDepthChildren<R>> List<R> toTreeDepth(List<T> sourceList,
                                                                       ITreeFirstTest<T> firstTest,
                                                                       Class<R> cls,
                                                                       ITreeParentTest<T> test) 
/**
 * 转换成树的类(带深度)
 *
 * @param sourceList 来源列表
 * @param firstTest  判断顶级结点的条件
 * @param cls        返回的类型
 * @param test       判断两个节点是否互为父子关系
 * @param <T>
 * @param <R>
 * @return
 */
public static <T, R extends ITreeDepthChildren<R>> List<R> toTreeDepth(List<T> sourceList,
                                                                       ITreeFirstTest<T> firstTest,
                                                                       Class<R> cls,
                                                                       ITreeParentTest<T> test,
                                                                       ITreeMapper<T, R> treeMapper,
                                                                       int firstDepth)
```

### Demo

com.digitalgd.portal.tree.TreeUtilTest

```java

public class TreeUtilTest {

    private ObjectMapper objectMapper;

    @BeforeEach
    void setUp() {
        objectMapper = new ObjectMapper();
    }

    private List<QueryItem> mockData() {

        // pid == 0 是作为一级节点

        List<QueryItem> list = new ArrayList<>();

        list.add(new QueryItem(1, 0, "ROOT1", null));
        list.add(new QueryItem(2, 0, "ROOT1", null));
        list.add(new QueryItem(3, 0, "ROOT1", null));
        list.add(new QueryItem(4, 0, "ROOT1", null));

        list.add(new QueryItem(5, 1, "ROOT1", null));
        list.add(new QueryItem(6, 1, "ROOT1", null));
        list.add(new QueryItem(7, 1, "ROOT1", null));

        list.add(new QueryItem(8, 2, "ROOT1", null));
        list.add(new QueryItem(9, 3, "ROOT1", null));
        list.add(new QueryItem(10, 4, "ROOT1", null));
        list.add(new QueryItem(11, 4, "ROOT1", null));

        list.add(new QueryItem(12, 11, "ROOT1", null));
        list.add(new QueryItem(13, 12, "ROOT1", null));
        list.add(new QueryItem(14, 13, "ROOT1", null));
        list.add(new QueryItem(15, 14, "ROOT1", null));


        return list;
    }

    /**
     * 转换成树,没有深度
     *
     * @throws JsonProcessingException
     */
    @Test
    public void treeNoDepth() throws JsonProcessingException {
        List<QueryItem> sourceList = mockData();
        // TreeItem 必须实现 ITreeChildren<TreeItem>
        List<TreeItem> tree = TreeUtil.toTree(sourceList, // 原来的列表
                node -> node.getPid() == 0, // 返回满足一级(顶级ROOT)节点的条件
                TreeItem.class,  // 转换成树的类
                (parent, child) -> parent.getId().equals(child.getPid()) // 两个节点是否为父子节点的条件判断
        );
        // 默认赋值使用 BeanUtils.copyProperties(source,target);
        String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

        System.out.println(s);
    }

    /**
     * 转换成树,没有深度
     *
     * @throws JsonProcessingException
     */
    @Test
    public void treeCustomNoDepth() throws JsonProcessingException {
        List<QueryItem> sourceList = mockData();
        // TreeItem 必须实现 ITreeChildren<TreeItem>
        List<TreeItem> tree = TreeUtil.toTree(sourceList, // 原来的列表
                node -> node.getPid() == 0, // 返回满足一级(顶级ROOT)节点的条件
                TreeItem.class,  // 转换成树的类
                (parent, child) -> parent.getId().equals(child.getPid()), // 两个节点是否为父子节点的条件判断
                (source, target) -> {
                    // 自定义方式 把原来节点(source)的数据赋值到目标节点(target)
                    target.setId(source.getId());
                    target.setName(source.getName());
                    target.setUrl(source.getUrl());
                });

        String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

        System.out.println(s);
    }

    /**
     * 默认转换器,树的深度起始为0
     *
     * @throws JsonProcessingException
     */
    @Test
    public void treeDepth() throws JsonProcessingException {
        List<QueryItem> sourceList = mockData();
        // TreeDepthItem 必须实现 ITreeDepthChildren<TreeDepthItem>

        List<TreeDepthItem> tree = TreeUtil.toTreeDepth(sourceList, // 原来的列表
                node -> node.getPid() == 0, // 返回满足一级(顶级ROOT)节点的条件
                TreeDepthItem.class,  // 转换成树的类
                (parent, child) -> parent.getId().equals(child.getPid()) // 两个节点是否为父子节点的条件判断
        );
        // 默认赋值使用 BeanUtils.copyProperties(source,target);
        String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

        System.out.println(s);
    }

    /**
     * 自定义转换器,树的深度起始为0
     *
     * @throws JsonProcessingException
     */
    @Test
    public void treeCustomDepth() throws JsonProcessingException {
        List<QueryItem> sourceList = mockData();
        // TreeDepthItem 必须实现 ITreeDepthChildren<TreeDepthItem>

        List<TreeDepthItem> tree = TreeUtil.toTreeDepth(sourceList, // 原来的列表
                node -> node.getPid() == 0, // 返回满足一级(顶级ROOT)节点的条件
                TreeDepthItem.class,  // 转换成树的类
                (parent, child) -> parent.getId().equals(child.getPid()),// 两个节点是否为父子节点的条件判断
                (source, target) -> {
                    // 自定义方式 把原来节点(source)的数据赋值到目标节点(target)
                    target.setId(source.getId());
                    target.setName(source.getName());
                    target.setUrl(source.getUrl());
                });
        // 默认赋值使用 BeanUtils.copyProperties(source,target);
        String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

        System.out.println(s);
    }


    /**
     * 自定义转换器,树的深度起始为 10
     *
     * @throws JsonProcessingException
     */
    @Test
    public void treeCustomDepth10() throws JsonProcessingException {
        List<QueryItem> sourceList = mockData();
        // TreeDepthItem 必须实现 ITreeDepthChildren<TreeDepthItem>

        List<TreeDepthItem> tree = TreeUtil.toTreeDepth(sourceList, // 原来的列表
                node -> node.getPid() == 0, // 返回满足一级(顶级ROOT)节点的条件
                TreeDepthItem.class,  // 转换成树的类
                (parent, child) -> parent.getId().equals(child.getPid()),// 两个节点是否为父子节点的条件判断
                (source, target) -> {
                    // 自定义方式 把原来节点(source)的数据赋值到目标节点(target)
                    target.setId(source.getId());
                    target.setName(source.getName());
                    target.setUrl(source.getUrl());
                },
                10);
        // 默认赋值使用 BeanUtils.copyProperties(source,target);
        String s = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(tree);

        System.out.println(s);
    }


}
```