java集合构建成树形集合TreeUtil

偏执的太偏执、 2023-10-07 18:23 20阅读 0赞

### 定义树形结构接口 ###

import java.util.List;
    
    /**
     * 树形结构基础类
     * @param <T>
     */
    public interface BaseTree<T> {
        
    
        String getId();
    
        void setId(String id);
    
        String getPid();
    
        void setPid(String pid);
    
        List<T> getChildren();
    
        void setChildren(List<T> children);
    }

### 模板方法+泛型进行封装的树形结构工具类 ###

package com.zm.decorator;
    
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * 树形结构工具类
     *  T 实现了BaseTree接口的实体对象，实体对象中默认有表示父子关系的id和pid
     *  N id和pid的类型
     *  由于 实体对象中表示父子关系的属性名称不一定是id和pid，所以提供了getId和getPid方法进行拓展
     */
    public abstract class TreeUtil<T extends BaseTree<T>, N> {
        
    
        /**
         * id的get方法
         *
         * @param t 对象
         * @return id 的值
         */
        protected abstract N getId(T t);
    
        /**
         * 父级id的get方法
         *
         * @param t 对象
         * @return pid 的值
         */
        protected abstract N getPid(T t);
    
        /**
         * 格式化成树形结构
         * 要点：非基本类型的变量存储的是内存地址，对它的操作会影响到原始值。
         *
         * @param list 要操作的列表
         * @return 树形结果列表
         */
        public List<T> parseTree(List<T> list) {
        
            if(list.isEmpty()){
        
                return list;
            }
            List<T> resultList = new ArrayList<>();
            // 知道有多少个元素，那么在创建的时候直接指定长度，避免因扩容而浪费时间
            Map<N, T> tmpMap = new HashMap<>(list.size());
            for (T t : list) {
        
                tmpMap.put(this.getId(t), t);
            }
            for (T t : list) {
        
                  /*1、tmpMap存储的是以id为key的键值对。
                   2、如果以pid为key可以从tmpMap中取出对象，则说明该元素是子级元素。
                   3、如果以pid为key不能从tmpMap中取出对象，则说明该元素是最上层元素。
                   4、子级元素放在父级元素的children中。
                   5、最上层元素添加到结果中
                   */
                T tmap = tmpMap.get(this.getPid(t));
                if (tmap != null) {
        
                    if (null == tmap.getChildren()) {
        
                        tmap.setChildren(new ArrayList<>());
                    }
                    tmap.getChildren().add(t);
                } else {
        
                    resultList.add(t);
                }
            }
            // 如果集合中存储了大量的元素，并且集合已经使用完毕，那么尽量调用clear方法来及时的释放空间。
            // 如果集合不会重复使用，那么将集合也设置为null将内存一并释放。这样有助于gc能更快完成清除内存的工作。
            list.clear();
            list = null;
            return resultList;
        }
    }

### 使用 ###

import java.util.List;
    
    public class TestNode implements BaseTree<TestNode>{
        
    
        private List<TestNode> children;
    
        private String id;
    
        private String pid;
    
        private String name;
    
        @Override
        public List<TestNode> getChildren() {
        
            return children;
        }
    
        @Override
        public void setChildren(List<TestNode> children) {
        
            this.children = children;
        }
    
        @Override
        public String getId() {
        
            return id;
        }
    
        @Override
        public void setId(String id) {
        
            this.id = id;
        }
    
        @Override
        public String getPid() {
        
            return pid;
        }
    
        @Override
        public void setPid(String pid) {
        
            this.pid = pid;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }

public static void main(String[] args) {
        
            ArrayList<TestNode> objects = getTestNodes();
            test1(objects);
        }
    
        private static void test1(ArrayList<TestNode> objects) {
        
    
            TreeUtil<TestNode, String> treeUtil = new TreeUtil<TestNode, String>() {
        
                @Override
                protected String getId(TestNode e) {
        
                    return e.getId();
                }
    
                @Override
                protected String getPid(TestNode e) {
        
                    return e.getPid();
                }
            };
    
            List<TestNode> testNodes = treeUtil.parseTree(objects);
            System.out.println(testNodes);
    
        }
    
        private static ArrayList<TestNode> getTestNodes() {
        
            TestNode testNode1 = new TestNode();
            testNode1.setName("中国");
            testNode1.setId("0");
    
            TestNode testNode2 = new TestNode();
            testNode2.setName("福建省");
            testNode2.setId("1");
            testNode2.setPid("0");
    
            TestNode testNode3 = new TestNode();
            testNode3.setName("浙江省");
            testNode3.setId("2");
            testNode3.setPid("0");
    
            TestNode testNode4 = new TestNode();
            testNode4.setName("福州市");
            testNode4.setId("3");
            testNode4.setPid("1");
    
    
            TestNode testNode5 = new TestNode();
            testNode5.setName("宁德市");
            testNode5.setId("4");
            testNode5.setPid("1");
    
    
            ArrayList<TestNode> objects = new ArrayList<>();
            objects.add(testNode1);
            objects.add(testNode2);
            objects.add(testNode3);
            objects.add(testNode4);
            objects.add(testNode5);
            return objects;
        }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAcXFfMjUwMDU2ODY4_size_20_color_FFFFFF_t_70_g_se_x_16]

### 上一版本写法有问题，代码优化后 ###

#### BaseTree ####

import java.util.List;
    
    /**
     * 树形结构基础类
     *
     * @param <T>
     * @author zhou
     */
    public interface BaseTree<T> {
        
    
        /**
         * 获取id
         *
         * @return
         */
        String getId();
    
        /**
         * 获取父id
         *
         * @return
         */
        String getPid();
    
        /**
         * 获取子集合
         *
         * @return
         */
        List<T> getChildren();
    
        /**
         * 赋子集合
         *
         * @return
         */
        void setChildren(List<T> children);
    
    }

#### TreeUtil ####

import org.apache.commons.lang3.StringUtils;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 树形结构工具类
     * T 实现了BaseTree接口的实体对象，实体对象中默认有表示父子关系的id和pid
     * N id和pid的类型
     * 由于 实体对象中表示父子关系的属性名称不一定是id和pid，所以提供了getId和getPid方法进行拓展
     *
     * @author zhou
     */
    public class TreeUtil {
        
    
        /**
         * 格式化成树形结构 JDK1.8以下版本
         * 要点：非基本类型的变量存储的是内存地址，对它的操作会影响到原始值。
         *
         * @param list 要操作的列表
         * @return 树形结果列表
         */
        public static <T extends BaseTree<T>> List<T> parseTree(List<T> list) {
        
            if (list.isEmpty()) {
        
                return list;
            }
            List<T> resultList = new ArrayList<>();
            // 知道有多少个元素，那么在创建的时候直接指定长度，避免因扩容而浪费时间
            Map<String, T> tmpMap = new HashMap<>(list.size());
            for (T t : list) {
        
                tmpMap.put(t.getId(), t);
            }
            for (T t : list) {
        
                  /*1、tmpMap存储的是以id为key的键值对。
                   2、如果以pid为key可以从tmpMap中取出对象，则说明该元素是子级元素。
                   3、如果以pid为key不能从tmpMap中取出对象，则说明该元素是最上层元素。
                   4、子级元素放在父级元素的children中。
                   5、最上层元素添加到结果中
                   */
                T tmap = tmpMap.get(t.getPid());
                if (tmap != null) {
        
                    if (null == tmap.getChildren()) {
        
                        tmap.setChildren(new ArrayList<>());
                    }
                    tmap.getChildren().add(t);
                } else {
        
                    resultList.add(t);
                }
            }
            // 如果集合中存储了大量的元素，并且集合已经使用完毕，那么尽量调用clear方法来及时的释放空间。
            // 如果集合不会重复使用，那么将集合也设置为null将内存一并释放。这样有助于gc能更快完成清除内存的工作。
            list.clear();
            list = null;
            return resultList;
        }
    
    }

#### TestNode ####

import lombok.Data;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Data
    public class TestNode implements BaseTree<TestNode>{
        
    
        private List<TestNode> children;
    
        private String iid;
    
        private String ipid;
    
        private String name;
    
    
        @Override
        public String getId() {
        
            return iid;
        }
    
        @Override
        public String getPid() {
        
            return ipid;
        }
    
        public static void main(String[] args) {
        
            ArrayList<TestNode> objects = getTestNodes();
            
            List<TestNode> testNodes = TreeUtil.parseTree(objects);
    
            System.out.println(testNodes);
        }
    
        private static ArrayList<TestNode> getTestNodes() {
        
            TestNode testNode1 = new TestNode();
            testNode1.setName("中国");
            testNode1.setIid("0");
    
            TestNode testNode2 = new TestNode();
            testNode2.setName("福建省");
            testNode2.setIid("1");
            testNode2.setIpid("0");
    
            TestNode testNode3 = new TestNode();
            testNode3.setName("浙江省");
            testNode3.setIid("2");
            testNode3.setIpid("0");
    
            TestNode testNode4 = new TestNode();
            testNode4.setName("福州市");
            testNode4.setIid("3");
            testNode4.setIpid("1");
    
    
            TestNode testNode5 = new TestNode();
            testNode5.setName("宁德市");
            testNode5.setIid("4");
            testNode5.setIpid("1");
    
    
            ArrayList<TestNode> objects = new ArrayList<>();
            objects.add(testNode1);
            objects.add(testNode2);
            objects.add(testNode3);
            objects.add(testNode4);
            objects.add(testNode5);
            return objects;
        }
    }

静态工具类使用起来超级简单了

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAcXFfMjUwMDU2ODY4_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/c67f1aec250d41b8bc52c5aa5340eefd.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAcXFfMjUwMDU2ODY4,size_20,color_FFFFFF,t_70,g_se,x_16