java集合快速構(gòu)建成樹形json實例

更新時間：2025年11月10日 15:17:42 作者：水煮魚又失敗了

文章介紹了如何使用Java構(gòu)建樹形結(jié)構(gòu)的JSON,并實現(xiàn)了一個代碼工具來簡化這一過程,該工具使用類適配器模式,允許靈活切換樹形結(jié)構(gòu),且無需修改實體類代碼,提高了代碼的可維護(hù)性和擴(kuò)展性

1 場景

1.1 面對問題

java中，經(jīng)常會需要構(gòu)建樹形結(jié)構(gòu)的json，如構(gòu)建一個省市區(qū)的樹形結(jié)構(gòu)。

此處情況，有如下幾個情況需要解決：

需要根據(jù)不同的前端組件，來定義不同格式的json（如easyui、ext里面的tree結(jié)構(gòu)均不同）。如切換組件，原代碼不適用
樹形結(jié)構(gòu)，需手動組裝，如不同的樹形結(jié)構(gòu)太多，則會花較多的時間來組裝不同業(yè)務(wù)的樹形結(jié)構(gòu)。
手動實現(xiàn)，代碼較復(fù)雜，容易出問題
如讓java中的實體類實現(xiàn)定義的樹形結(jié)構(gòu)的接口，代碼侵入性太強

1.2 實現(xiàn)目標(biāo)

這里實現(xiàn)一個代碼工具，各位朋友可以參考下，實現(xiàn)如下功能：

實現(xiàn)樹形結(jié)構(gòu)的快速構(gòu)建
定義不同樹類型的實現(xiàn)，可切換樹形結(jié)構(gòu)簡單
系統(tǒng)實體類無需實現(xiàn)自定義接口，代碼無侵入性
使用類適配器，可隨意自行擴(kuò)展

2 代碼結(jié)構(gòu)圖

3 實現(xiàn)效果

依賴model：

package com.sa.example.tree.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 區(qū)域信息
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Area {

    private String areaCode;
    
    private String areaName;
    
    private Integer order;
    
    private String parentCode;
    
}

3.1 調(diào)用

package com.sa.example.tree.test;

import com.sa.example.tree.*;
import com.sa.example.tree.ext.EasyuiNode;
import com.sa.example.tree.bean.Area;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class TreeParseTest {
    
    @Test
    public void testParse(){
    
        // 節(jié)點轉(zhuǎn)換器（將任意對象轉(zhuǎn)換為樹節(jié)點）
        NodeConvert departmentConverter = new NodeConvert<Area>() {
            @Override
            public Node convert(Area area) {
                // 根據(jù)實體的屬性，補充到對應(yīng)的NodeInstance對象上（轉(zhuǎn)換為EasyUi）
                NodeInstance instance = new EasyuiNode();
                instance.setParentCode(area.getParentCode());
                instance.setCode(area.getAreaCode());
                instance.setName(area.getAreaName());
                instance.setOrder(area.getOrder());
                // 根據(jù)實際業(yè)務(wù)，配置其他屬性......
                /*instance.setCss("icon-value");
                instance.setChecked(true);
                instance.setState("opened");
                instance.putExtMap("aa", "aaVaule");*/
            
                return instance;
            }
        };
    
        // 默認(rèn)根節(jié)點選擇器（確定根節(jié)點）
        RootSelector defaultSelector = new RootSelector() {
            @Override
            public boolean select(Node node) {
                if (node != null && StringUtils.isEmpty(node.getParentCode())) {
                    return true;
                }
                return false;
            }
        };
    
        List<Area> areaList = new ArrayList<>();
        areaList.add(new Area("130000000000", "河北", 2, ""));
        areaList.add(new Area("130100000000", "石家莊", 1, "130000000000"));
        areaList.add(new Area("130400000000", "邯鄲", 2, "130000000000"));
        areaList.add(new Area("370000000000", "山東", 1, ""));
        areaList.add(new Area("370100000000", "濟(jì)南", 1, "370000000000"));
        areaList.add(new Area("370200000000", "青島", 2, "370000000000"));
        areaList.add(new Area("370202000000", "市南", 2, "370200000000"));
        areaList.add(new Area("370203000000", "市北", 3, "370200000000"));
        
        TreeBuilder<Area> treeBuilder = new TreeBuilder<>(departmentConverter, defaultSelector);
        Tree tree = treeBuilder.build(areaList);
        System.out.println(tree.toJson());
    }
}

3.2 結(jié)果

[{
	"children": [{
		"id": "370100000000",
		"text": "濟(jì)南"
	}, {
		"children": [{
			"id": "370202000000",
			"text": "市南"
		}, {
			"id": "370203000000",
			"text": "市北"
		}],
		"id": "370200000000",
		"text": "青島"
	}],
	"id": "370000000000",
	"text": "山東"
}, {
	"children": [{
		"id": "130100000000",
		"text": "石家莊"
	}, {
		"id": "130400000000",
		"text": "邯鄲"
	}],
	"id": "130000000000",
	"text": "河北"
}]

4 實現(xiàn)代碼

maven依賴：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

4.1 JSON轉(zhuǎn)換器

/**
 * JSON轉(zhuǎn)換器
 */
public interface JsonParser {
    
    /**
     * 生成JSON對象
     * @return JSON對象
     */
    JSONObject toJson();
    
}

4.2 節(jié)點

package com.sa.example.tree;

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

/**
 * 節(jié)點
 */
public interface Node extends JsonParser, Comparable<Node> {
    
    /**
     * 獲取節(jié)點代碼
     *
     * @return
     */
    String getCode();
    
    /**
     * 獲取節(jié)點名稱
     *
     * @return
     */
    String getName();
    
    /**
     * 獲取節(jié)點排序
     *
     * @return
     */
    Integer getOrder();
    
    /**
     * 獲取節(jié)點樣式
     *
     * @return
     */
    String getCss();
    
    /**
     * 獲取節(jié)點狀態(tài)
     *
     * @return
     */
    String getState();
    
    /**
     * 獲取節(jié)點復(fù)選狀態(tài)
     *
     * @return
     */
    Boolean getChecked();
    
    /**
     * 擴(kuò)展屬性
     *
     * @return
     */
    Map<String, Object> getExtMap();
    
    /**
     * 獲取父節(jié)點代碼
     *
     * @return
     */
    String getParentCode();
    
    /**
     * 獲取子節(jié)點集合
     *
     * @return
     */
    List<Node> getChildList();
    
    @Override
    default int compareTo(Node o) {
        return this.getOrder().compareTo(o.getOrder());
    }
    
    /**
     * 添加子節(jié)點
     *
     * @param node 子節(jié)點
     */
    void addChildNode(Node node);
    
    /**
     * 設(shè)置額外屬性
     * @param key
     * @param value
     */
    void putExtMap(String key, Object value);
}

4.3 節(jié)點實例

package com.sa.example.tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Node實例
 */
public abstract class NodeInstance implements Node {
    
    /**
     * 節(jié)點代碼
     */
    private String code;
    
    /**
     * 節(jié)點名稱
     */
    private String name;
    
    /**
     * 節(jié)點排序
     */
    private Integer order;
    
    /**
     * 節(jié)點樣式
     */
    private String css;
    
    /**
     * 節(jié)點狀態(tài)
     */
    private String state;
    
    /**
     * 節(jié)點復(fù)選狀態(tài)
     */
    private Boolean checked;
    
    /**
     * 擴(kuò)展屬性
     */
    private Map<String, Object> extMap;
    /**
     * 父節(jié)點代碼
     */
    private String parentCode;
    
    /**
     * 子節(jié)點集合
     */
    private List<Node> childList;
    
    @Override
    public void addChildNode(Node node) {
        if (childList == null) {
            childList = new ArrayList<>();
        }
        childList.add(node);
    }
    
    @Override
    public List<Node> getChildList() {
        return childList;
    }
    
    @Override
    public void putExtMap(String key, Object value) {
        if (extMap == null) {
            extMap = new HashMap<>();
        }
        extMap.put(key, value);
    }
    
    @Override
    public String getCode() {
        return code;
    }
    
    public void setCode(String code) {
        this.code = code;
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public Integer getOrder() {
        return order;
    }
    
    public void setOrder(Integer order) {
        this.order = order;
    }
    
    @Override
    public String getCss() {
        return css;
    }
    
    public void setCss(String css) {
        this.css = css;
    }
    
    @Override
    public String getState() {
        return state;
    }
    
    public void setState(String state) {
        this.state = state;
    }
    
    @Override
    public Boolean getChecked() {
        return checked;
    }
    
    public void setChecked(Boolean checked) {
        this.checked = checked;
    }
    
    @Override
    public String getParentCode() {
        return parentCode;
    }
    
    public void setParentCode(String parentCode) {
        this.parentCode = parentCode;
    }
    
    @Override
    public Map<String, Object> getExtMap() {
        return extMap;
    }
}

4.4 根節(jié)點選擇器

package com.sa.example.tree;

/**
 * 根節(jié)點選擇器
 */
public interface RootSelector {
    
    /**
     * 選擇節(jié)點為根節(jié)點
     * @param node 被選擇節(jié)點
     * @return true：選擇為根節(jié)點；false：不選擇為根節(jié)點
     */
    boolean select(Node node);

}

4.5 節(jié)點轉(zhuǎn)換器

/**
 * 節(jié)點轉(zhuǎn)換器
 */
public interface NodeConvert<T> {
    
    /**
     * 實體轉(zhuǎn)換為節(jié)點
     * @param t
     * @return
     */
    Node convert(T t);
    
}

4.6 樹

package com.sa.example.tree;

import com.alibaba.fastjson.JSONArray;
import org.apache.commons.collections4.CollectionUtils;

import java.util.List;

/**
 * 樹
 */
public class Tree {
    
    /**
     * 根節(jié)點
     */
    private List<Node> nodeList;
    
    public Tree() {
    }
    
    public void setNodeList(List<Node> nodeList) {
        this.nodeList = nodeList;
    }
    
    public String toJson() {
        JSONArray jsonArray = new JSONArray();
    
        if (CollectionUtils.isNotEmpty(nodeList)) {
            for (Node node : nodeList) {
                jsonArray.add(node.toJson());
            }
        }
        return jsonArray.toJSONString();

    }
}

4.7 樹構(gòu)建器

package com.sa.example.tree;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * 樹構(gòu)建器
 *
 * @param <T>
 */
public class TreeBuilder<T> {
    
    /**
     * 節(jié)點轉(zhuǎn)換器
     */
    private NodeConvert<T> nodeConvert;
    
    /**
     * 根節(jié)點選擇器
     */
    private RootSelector rootSelector;
    
    public TreeBuilder(NodeConvert nodeConvert, RootSelector rootSelector) {
        this.nodeConvert = nodeConvert;
        this.rootSelector = rootSelector;
    }
    
    /**
     * 初始化節(jié)點列表
     *
     * @return
     */
    protected List<Node> initNodeList(List<T> list) {
        List<Node> nodeList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(list)) {
            for (T model : list) {
                nodeList.add(nodeConvert.convert(model));
            }
        }
        return nodeList;
    }
    
    /**
     * 構(gòu)建節(jié)點結(jié)構(gòu)
     *
     * @param nodeList
     * @return
     */
    protected List<Node> buildNodeStructure(List<Node> nodeList) {
        List<Node> rootList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(nodeList)) {
            // 1、構(gòu)建root節(jié)點
            Iterator<Node> iterator = nodeList.iterator();
            while (iterator.hasNext()) {
                Node node = iterator.next();
                if (rootSelector.select(node)) {
                    rootList.add(node);
                    iterator.remove();
                }
            }
            // 2、循環(huán)查找子節(jié)點
            for (Node rootNode : rootList) {
                this.buildChildNode(rootNode, nodeList);
            }
        }
        
        return rootList;
    }
    
    /**
     * 構(gòu)建子節(jié)點（反復(fù)調(diào)用）
     *
     * @param parentNode     父節(jié)點
     * @param originNodeList 自己節(jié)點列表
     */
    protected void buildChildNode(Node parentNode, List<Node> originNodeList) {
        if (CollectionUtils.isNotEmpty(originNodeList)) {
            Iterator<Node> iterator = originNodeList.iterator();
            while (iterator.hasNext()) {
                Node node = iterator.next();
                if (StringUtils.equals(parentNode.getCode(), node.getParentCode())) {
                    parentNode.addChildNode(node);
                    iterator.remove();
                    // 迭代調(diào)用
                    this.buildChildNode(node, originNodeList);
                }
            }
        }
    }
    
    /**
     * 節(jié)點集合排序
     *
     * @param nodeList
     * @return
     */
    protected void sortNodeList(List<Node> nodeList) {
        if (CollectionUtils.isNotEmpty(nodeList)) {
            Collections.sort(nodeList);
            for (Node node : nodeList) {
                if (CollectionUtils.isNotEmpty(node.getChildList())) {
                    this.sortNodeList(node.getChildList());
                }
            }
        }
    }
    
    /**
     * 構(gòu)建樹
     *
     * @param list
     * @return
     */
    public Tree build(List<T> list) {
        List<Node> nodeList = this.initNodeList(list);
        List<Node> buildNodeList = this.buildNodeStructure(nodeList);
        this.sortNodeList(buildNodeList);
        
        Tree tree = new Tree();
        tree.setNodeList(buildNodeList);
        return tree;
    }
    
}

4.8 Easyui節(jié)點實例

實例繼承自“節(jié)點實例NodeInstance”，此類實例可根據(jù)實際要求自行定義和擴(kuò)展。

package com.sa.example.tree.ext;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.sa.example.tree.Node;
import com.sa.example.tree.NodeInstance;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;

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

/**
 * Easyui節(jié)點實例
 */
public class EasyuiNode extends NodeInstance {
    @Override
    public JSONObject toJson() {
        JSONObject jsonObject = new JSONObject();
        // ==========【（1）組裝必有屬性】==========
        jsonObject.put("id", this.getCode());
        jsonObject.put("text", this.getName());
        
        // ==========【（2）組裝可選屬性】==========
        String css = this.getCss();
        if (StringUtils.isNotEmpty(css)) {
            jsonObject.put("iconCls", css);
        }
        String state = this.getState();
        if (StringUtils.isNotEmpty(state)) {
            jsonObject.put("state", state);
        }
        Boolean checked = this.getChecked();
        if (checked != null) {
            jsonObject.put("checked", checked);
        }
        
        Map<String, Object> extMap = this.getExtMap();
        if (MapUtils.isNotEmpty(extMap)) {
            JSONObject attributesObject = new JSONObject();
            for (Map.Entry<String, Object> entry : extMap.entrySet()) {
                attributesObject.put(entry.getKey(), entry.getValue());
            }
            jsonObject.put("attributes", attributesObject);
        }
        
        // ==========【（3）組裝子節(jié)點】==========
        List<Node> childList = this.getChildList();
        if (CollectionUtils.isNotEmpty(childList)) {
            JSONArray jsonArray = new JSONArray();
            for (Node child : childList) {
                jsonArray.add(child.toJson());
            }
            jsonObject.put("children", jsonArray);
        }
        return jsonObject;
    }   
}