java 把DataTable数据类型转换为树形结构（多叉树）

问题分析：一个关系数据库的表，如图所示：



可以看到后面四个字段：Country，Province，City，Street 具有逻辑上的从属结构，现在要把这种数据搞成一个树形结构，如图所示：



不是原来的数据转换而成的，大致就是这个意思，可以想象成，dataTable里面相同的数据进行单元格合并，然后找到所有的从根到叶子节点的路径，就算完成任务。JS里面似乎有很多插件可以实现，但Java中我暂时还没找到，没办法只能自己写了。从结构上看，应该是一个多叉多级树形结构，所以在转换的时候必须具备一定的灵活性，节点的层级也要分明。

首先定义一个node类，描述节点：

public class Node {
private String id;
private String pId;
private String text;
private Map<String, Object> nodeValue;
private String path;
public Node() {

}
public Node(String id,String pId,String text,String path){
this.id = id;
this.pId = pId;
this.text = text;
this.path = path;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getpId() {
return pId;
}
public void setpId(String pId) {
this.pId = pId;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public Map<String, Object> getNodeValue() {
return nodeValue;
}
public void setNodeValue(Map<String, Object> nodeValue) {
this.nodeValue = nodeValue;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
@Override
public String toString() {
String str = "";
if(this.nodeValue!=null){
Set<Entry<String,Object>> entrySet = this.nodeValue.entrySet();
for (Entry<String, Object> entry : entrySet) {
str+=entry.getKey()+"="+entry.getValue();
}
}
return str;
}
}

简单说明一下设计初衷：

1，id和pid就不说了，明眼人一眼就看穿了。text表示的是节点当前显示内容。

2，nodeValue是Map结构，包含从当前节点到根节点的text，比如：三级节点City=QingDao的nodeValue包含说明什么呢？答案：{city=QingDao,province=ShanDong,country=China}

3，path属性表示节点的地址，或者叫做路径，用来标识某个节点是否已存在，样式举例：/China/ShanDong/QingDao

看具体实现类：

public class MultiTree {
private List<Node> nodeList;
private Node rootNode;

public List<Node> getNodeList() {
return nodeList;
}

public void setNodeList(List<Node> nodeList) {
this.nodeList = nodeList;
}

public MultiTree() {
init();
}

public MultiTree(List<Node> nodeList, Node rootNode) {
this();
if (nodeList != null) {
this.nodeList = nodeList;
}
if (rootNode != null) {
this.rootNode = rootNode;
}
}

private void init() {
nodeList = new ArrayList<Node>();
rootNode = new Node("0", "-1", "0", "/");
}

/**
* 把DataTable数据转换为DataTree,保证path唯一
* @param listMaps
* @param args
*/
public void convertListMapToTree(List<Map<String, Object>> listMaps,
String... args) {
Object value = null;
String path = "";
Node pNode = null;
Node node = null;
Map<String, Object> nodeValue = new HashMap<String, Object>();
nodeList.add(rootNode);
for (Map<String, Object> map : listMaps) {
path = "";
pNode = getRoot();
for (int i = 0;i < args.length;i++) {
String key = args[i];
value = map.get(key);
path += "/" + value;
node = findNodeByPath(path);
if (node == null) {
node = new Node(IdGenerator.uuidGenerator(), pNode.getId(),
String.valueOf(value), path);
if(i==args.length-1){
nodeValue = map;
}else{
nodeValue = getNodeValueByPath(path,args);
}
node.setNodeValue(nodeValue);
nodeList.add(node);
} else {
pNode = node;
}
}
}
}
/**
* 根据node path node应该有nodeValue
* nodeValue 应该包含父节点的Text，而不应该包含子节点的text,叶子节点应该包含所有的值
* @param path
* @param args
* @return
*/
private Map<String, Object> getNodeValueByPath(String path, String[] args) {
Map<String, Object> nodeValue = new HashMap<String, Object>();
String[] values = path.split("/");

for (int i = 1;i < values.length;i++) {
nodeValue.put(args[i-1], values[i]);
}
return nodeValue;
}

public Node getRoot() {
return rootNode;
}
/**
* 某个节点的所有子节点
* @param pNode
* @return
*/
public List<Node> getChildNodes(Node pNode) {
List<Node> childNodes = new ArrayList<Node>();
if (pNode == null || pNode.getId() == null) {
return childNodes;
}
for (Node node : nodeList) {
if (pNode.getId().equals(node.getpId())) {
childNodes.add(node);
}
}
return childNodes;
}
/**
* 根据path查找node是否存在（因path唯一）
* @param path
* @return 找到node返回，否则返回null
*/
public Node findNodeByPath(String path) {
for (Node node : nodeList) {
if (path.equals(node.getPath())) {
return node;
}
}
return null;
}
/**
* 从某个节点开始进行深度度递归遍历
* @param pNode
*/
public void recursionTraversal(Node pNode){
List<Node> childNodes = getChildNodes(pNode);
for (Node node : childNodes) {
System.out.println(node.toString());
if(getChildNodes(node).size()>0){
recursionTraversal(node);
}
}
}
}

此类的核心方法是：  convertListMapToTree 参数，是数据源和节点的字段名称。

调用方式：

tree.convertListMapToTree(listMaps, "COUNTRY","PROVINCE","CITY","STREET");

执行结果：

/
/China
/China/HeBei
/China/HeBei/BaoDing
/China/HeBei/BaoDing/street1
/China/HeBei/HengShui
/China/HeBei/HengShui/street1
/China/ShanDong
/China/ShanDong/Jian
/China/ShanDong/Jian/street1
/China/ShanDong/QingDao
/China/ShanDong/QingDao/street1
/China/ShanDong/YanTai
/China/ShanDong/YanTai/street1
/Japan
/Japan/JiuZhou
/Japan/JiuZhou/ChangQi
/Japan/JiuZhou/ChangQi/street2
/America
/America/California
/America/California/Los Angeles
/America/California/Los Angeles/street3
/England
/England/Norwich
/England/Norwich/Any
/England/Norwich/Any/street4


此处有几个点需要注意：

1，字段名称参数传递的顺序就是节点的层级顺序，从高到低，若是写错，则结果不准确。

2，一定要有一个根节点，这是树形结构的必备，程序中已给出默认根节点，也给出了自定义的接口。

3，本程序中，nodeValue中只包含（叶子节点除外）从当前节点到根节点的字段值，叶子节点包含所有的字段值，比如本例，叶子节点中也包含ID=1这样的数据，虽然没有被应用到节点层级中。

4,判断path是否存在是关键一步，如果该步骤不能准确，则整个程序就以失败告终。

不足之处：

很多地方都在全局查找，效率较低，期待后续改进。