我在数据库中有一个父子关系（Tree Structure），我想遍历它并创建一个json对象。
我的数据库中的父子关系结构（演示数据）。
child_id parent_id Item_Name
1 1 Country
2 1 Australia
3 2 Victoria
4 2 Queensland
5 1 Canada
6 5 British Columbia
7 6 Vancouver
8 8 Songs
9 8 Song1
10 8 Song2
11 10 lyrics 1st
12 10 lyrics 2nd
13 13 Germany
14 14 England
15 14 London
如何工作
if(child_id == parent_id)
{
// This item is parent. Like Country,Songs,Germany, England
} else {
// This item is child. Like Australia, Song1, Vancouver etc.
}
现在，我知道如何遍历这样的结构，但在将其转换为json对象时遇到了麻烦。
伪代码 DFS树
获取所有父母的
List data = fetch data from table where parent_id=child_id
现在穿越这个 资料
Recursively iterate through child elements
get child_id from data object and query on database it as parent_id, to get its child elements and so on.
但是，如何将其转换为JSON对象，比如说
{
"country": [
{
"Australia": [
"Victoria",
"Queensland"
]
},
{
"Canada": [
{
"British Columbia": [
"Vancouver"
]
}
]
}
]
},
{
"Songs": [
"Songs1",
{
"Songs2": [
"lyrics 1st",
"lyrics 2nd"
]
}
]
},
{
"Germany": null
},
{
"England": ["London"]
}
或一个json对象，其中 亲子关系.
首先，你提供的JSON不是一个有效的JSON。所以，我在生成JSON时添加了一个父根节点。
如果你在你的数据集中定义了一个根节点，那么你的结构会有小的变化，因为你不能像当前的数据集一样保持parent_Id = child_id的关系，所以也会对解决方案进行修改。
首先你需要将你的数据映射到一些父子支持的数据类型中。我已经创建了 Node.java 为此目的。介绍了 addChild 方法来逐个添加子代。
import java.util.ArrayList;
import java.util.List;
public class Node
{
private String nodeName;
private java.util.List<Node> children = new ArrayList<Node>();
public Node( String nodeName )
{
this.nodeName = nodeName;
}
public List<Node> getChildren()
{
return children;
}
public void setChildren( List<Node> children )
{
this.children = children;
}
public String getNodeName()
{
return nodeName;
}
public void setNodeName( String nodeName )
{
this.nodeName = nodeName;
}
public void addChild( Node node )
{
this.children.add( node );
}
}
而对于你最初的数据类型，我创建了 Mapping.java
public class Mapping
{
private int parentId;
private int childId;
private String ItemName;
public Mapping( int parentId, int childId, String itemName )
{
this.parentId = parentId;
this.childId = childId;
ItemName = itemName;
}
public int getParentId()
{
return parentId;
}
public void setParentId( int parentId )
{
this.parentId = parentId;
}
public int getChildId()
{
return childId;
}
public void setChildId( int childId )
{
this.childId = childId;
}
public String getItemName()
{
return ItemName;
}
public void setItemName( String itemName )
{
ItemName = itemName;
}
}
现在加载和数据并填充Node对象，得到最终的Json就在这里完成。我这里使用的是对象引用映射，因为我们无法保证你数据库中映射的顺序。因为子代是分配给父代的对象引用的，完成分配后，我们就有了父子结构。这两个循环也是出于同样的原因。在开始构建结构之前，我们需要确保map拥有所有节点。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ParentChild
{
public static void main( String[] args )
{
List<Mapping> list = new ArrayList<Mapping>();
list.add( new Mapping( 1, 1, "Country" ) );
list.add( new Mapping( 1, 2, "Australia" ) );
list.add( new Mapping( 2, 3, "Victoria" ) );
list.add( new Mapping( 2, 4, "Queensland" ) );
list.add( new Mapping( 1, 5, "Canada" ) );
list.add( new Mapping( 5, 6, "British Columbia" ) );
list.add( new Mapping( 6, 7, "Vancouver" ) );
list.add( new Mapping( 8, 8, "Songs" ) );
list.add( new Mapping( 8, 9, "Song1" ) );
list.add( new Mapping( 8, 10, "Song2" ) );
list.add( new Mapping( 10, 11, "lyrics 1st" ) );
list.add( new Mapping( 10, 12, "lyrics 2nd" ) );
list.add( new Mapping( 13, 13, "Germany" ) );
list.add( new Mapping( 14, 14, "England" ) );
list.add( new Mapping( 14, 15, "London" ) );
Map<Integer, Node> map = new HashMap<Integer, Node>();
map.put( -1, new Node( "root" ) ); // give index -1 for the root
for( Mapping mapping : list ) // keep a map of nodes by child id
{
map.put( mapping.getChildId(), new Node( mapping.getItemName() ) );
}
for( Mapping mapping : list )
{
if( mapping.getParentId() == mapping.getChildId() )
{
map.get( -1 ).addChild( map.get( mapping.getChildId() ) ); // add to the root
}
else
{
Node node = map.get( mapping.getParentId() );
Node childNode = map.get( mapping.getChildId() );
node.addChild( childNode ); // add to the relevant parent
}
}
StringBuilder json = new StringBuilder();
writeJson( map.get( -1 ), json ); // root node is enough
System.out.println( json );
}
private static void writeJson( Node node, StringBuilder json )
{
if( node.getChildren().isEmpty() ) // no children. return just the node name
{
json.append( "\"" ).append( node.getNodeName() ).append( "\"" );
}
else
{
json.append( "{\"" ).append( node.getNodeName() ).append( "\": [" );
List<Node> children = node.getChildren();
for( int i = 0; i < children.size(); i++ )
{
Node child = children.get( i );
writeJson( child, json ); // call recursively
if( i != children.size() - 1 ) // skip , for the last child
{
json.append( "," );
}
}
json.append( "]}" );
}
}
}
我使用了一个递归的方法来构建json。
最终的json
{
"root":[
{
"Country":[
{
"Australia":[
"Victoria",
"Queensland"
]
},
{
"Canada":[
{
"British Columbia":[
"Vancouver"
]
}
]
}
]
},
{
"Songs":[
"Song1",
{
"Song2":[
"lyrics 1st",
"lyrics 2nd"
]
}
]
},
"Germany",
{
"England":[
"London"
]
}
]
}
希望对你有所帮助。