一、创建TreeNodes实体类
import com.alibaba.druid.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
public class TreeNodes implements Comparable<TreeNodes> {//实现Comparable接口,实现根据level排序
//实体类主键(必须字段),用于与上级绑定
private String id;
//父级ID(必须字段),用于与下级绑定
private String pId;
//实体类层级(必须字段)
private String level;
//实体类名称(非必须,可替换为其它一个或多个参数)
private String text;
private List<TreeNodes> children = new ArrayList<>();
public TreeNodes() {
}
;
/**
* @param id 一般为主键
* @param pId 父id
* @param text 标签名称
* @param level 层级
*/
public TreeNodes(String id, String pId, String text, String level) {
this.id = StringUtils.isEmpty(id) ? "id" : id;
this.pId = StringUtils.isEmpty(pId) ? "pId" : pId;
this.text = StringUtils.isEmpty(text) ? "text" : text;//非必须,可替换为其它一个或多个参数
this.level = StringUtils.isEmpty(level) ? "level" : level;
}
@Override
public int compareTo(TreeNodes tn) {
//1排在当前的后面//-1排在当前的前面
int big = 1, small = -1, eq = 0;
if (tn == null || tn.getLevel() == null) {
return big;
} else if (this.getLevel() == null) {
return small;
} else if (Integer.valueOf(tn.getLevel()) < Integer.valueOf(this.getLevel())) {
return big;
} else if (Integer.valueOf(tn.getLevel()) > Integer.valueOf(this.getLevel())) {
return small;
}
return eq;
}
//省略getter、setter方法
}
二、引入fastJson包
maven引入fastJson
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
纯JAVA项目可以直接下载fastjson.jar
com.alibaba.druid.jar
,导入项目
三、工具类
注:如果转换为树仍为原类型(User-->User
,而不是User-->TreeNodes
),只需修改formatTree
方法里标有//change
注释的地方,将条件修改为自己匹配的条件即可;
注:List对象需按levels从小到大排列,否则会造成数据丢失,查看List对象排序方法。
调用Tools.formatTree(users,keys)
执行树的生成操作。
import com.alibaba.druid.util.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import java.util.*;
public class Tools {
public static void main(String[] args) {//测试用例
TreeNodes keys = new TreeNodes("ptId", "parentId", "ptName", "ptLevels");
//String str = "[{\"parentId\":\"0\",\"ptDeleted\":\"0\",\"ptId\":\"1\",\"ptLevels\":1,\"ptName\":\"类型1\"},{\"parentId\":\"0\",\"ptDeleted\":\"0\",\"ptId\":\"2\",\"ptLevels\":1,\"ptName\":\"类型2\"},{\"parentId\":\"2\",\"ptDeleted\":\"0\",\"ptId\":\"3\",\"ptLevels\":2,\"ptName\":\"类型23\"}]";
//String s1 = changeKey(str, keys);
//System.out.println(s1);
List<Map<String, Object>> pts = getListMap();//模拟获取列表信息
List<TreeNodes> list = Tools.formatTree(pts, keys);//将列表转换为树
System.out.println(JSON.toJSONString(list));
}
public static List<Map<String, Object>> getListMap() {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map6 = new HashMap<String, Object>();
map6.put("ptId", 6); map6.put("parentId", 3); map6.put("ptLevels", 2); map6.put("ptName", "测试用例6");
list.add(map6);
Map<String, Object> map7 = new HashMap<String, Object>();
map7.put("ptId", 7); map7.put("parentId", 4); map7.put("ptLevels", 3); map7.put("ptName", "测试用例7");
list.add(map7);
Map<String, Object> map1 = new HashMap<String, Object>();
map1.put("ptId", 1); map1.put("parentId", 0); map1.put("ptLevels", 1); map1.put("ptName", "测试用例1");
list.add(map1);
Map<String, Object> map2 = new HashMap<String, Object>();
map2.put("ptId", 2); map2.put("parentId", 0); map2.put("ptLevels", 1); map2.put("ptName", "测试用例2");
list.add(map2);
Map<String, Object> map3 = new HashMap<String, Object>();
map3.put("ptId", 3); map3.put("parentId", 0); map3.put("ptLevels", 1); map3.put("ptName", "测试用例3");
list.add(map3);
Map<String, Object> map4 = new HashMap<String, Object>();
map4.put("ptId", 4); map4.put("parentId", 1); map4.put("ptLevels", 2); map4.put("ptName", "测试用例4");
list.add(map4);
Map<String, Object> map5 = new HashMap<String, Object>();
map5.put("ptId", 5); map5.put("parentId", 2); map5.put("ptLevels", 2); map5.put("ptName", "测试用例5");
list.add(map5);
Map<String, Object> map8 = new HashMap<String, Object>();
map8.put("ptId", 8); map8.put("parentId", 5); map8.put("ptLevels", 3); map8.put("ptName", "测试用例8");
list.add(map8);
return list;
}
/**
* @param list 树的内容,需要按照level从小到大进行排序,否则无法获取到第一个层级,且易造成树的分支丢失
* @param keys
* @param <T>
* @return
*/
public static <T> List<TreeNodes> formatTree(List<T> list, TreeNodes keys) {
if (list == null || list.size() <= 0) {
return new ArrayList<>();
}
String jsonStr = JSON.toJSONString(list);
jsonStr = changeKey(jsonStr, keys);//change,不改变格式,不需要这段代码,直接删除
List<TreeNodes> treeNodes = listClone(jsonStr, TreeNodes.class);//change,不改变格式,不需要这段代码,直接删除
Collections.sort(treeNodes);//排序
Map<String, List<TreeNodes>> map = new HashMap<>();//change,修改List为指定的类型
//转换字段
List<TreeNodes> root = null;//根目录 //change,修改List为指定的类型
for (TreeNodes current : treeNodes) {//change,修改List为指定的类型
{//添加当前元素到指定级别
String level = current.getLevel();//change,修改获取层级的方法
if (!map.containsKey(level)) {//不存在,先添加list
map.put(level, new ArrayList<TreeNodes>());//change,修改List为指定的类型
}
List<TreeNodes> arr = map.get(level);//当前层级//change,修改List为指定的类型
arr.add(current);
if (root == null) {//表示是第一级
root = arr;
}
}
//将当前元素添加到父级的子元素列表里
{
List<TreeNodes> parentTree = map.get(String.valueOf(Integer.valueOf(current.getLevel()) - 1));//change,修改List、获取层级的方法
if (parentTree == null) {
continue;
}
for (TreeNodes parent : parentTree) {//change,修改List为指定的类型
if (parent.getId().equals(current.getPId())) {//如果找不到父级,则为异常数据,抛弃 //change,修改上下级关联的判断依据
parent.getChildren().add(current);
break;
}
}
}
}
return root;
}
/**
* 更新字段
*/
public static String changeKey(String json, TreeNodes keys) {
if (StringUtils.isEmpty(json) || keys == null) {
return "";
}
json = json.replaceAll(keys.getId(), "id")
.replaceAll(keys.getText(), "text")
.replaceAll(keys.getPId(), "pId")
.replaceAll(keys.getLevel(), "level");
return json;
}
/**
* 将一个对象的列表转换为另一个对象的列表
*
* @param k
* @param clazz
* @param <T>
* @param <K>
* @return
*/
public static <T, K> List<T> listClone(List<K> k, Class<T> clazz) {
List<T> list = JSONArray.parseArray((JSONArray.toJSON(k)).toString(), clazz);
return list;
}
/**
* 将json格式的字符串转换为指定对象的列表
*
* @param str
* @param clazz
* @param <T>
* @return
*/
public static <T> List<T> listClone(String str, Class<T> clazz) {
List<T> list = JSONArray.parseArray(str, clazz);
return list;
}
}
输出结果
[{
"id": "1",
"level": "1",
"pId": "0",
"text": "测试用例1",
"children": [{
"id": "4",
"level": "2",
"pId": "1",
"text": "测试用例4",
"children": [{
"id": "7",
"level": "3",
"pId": "4",
"text": "测试用例7",
"children": []
}]
}],
}, {
"id": "2",
"level": "1",
"pId": "0",
"text": "测试用例2",
"children": [{
"id": "5",
"level": "2",
"pId": "2",
"text": "测试用例5",
"children": [{
"id": "8",
"level": "3",
"pId": "5",
"text": "测试用例8",
"children": [],
}]
}]
}, {
"id": "3",
"level": "1",
"pId": "0",
"text": "测试用例3",
"children": [{
"id": "6",
"level": "2",
"pId": "3",
"text": "测试用例6",
"children": []
}]
}]