java树结构
1. javaweb里面树形结构（tree）
这个是java中的forEach循环，和
for(inti=0;i<10;i++){...}还是有点区别的。有问题可以继续 问。
2. java使用递归实现树形结构
sql">
inserttb_menu(id,name,parent)(640000000000,北京市,0);
inserttb_menu(id,name,parent)(640100000000,昌平区,1);
inserttb_menu(id,name,parent)(640101000000,霍营,2);
inserttb_menu(id,name,parent)(640101001000,回龙观东大街,3);
添加一个节点属性， 根据数据不同代表的地位不同，0就代表父节点 ，1是0的子节点，2是1的子节点，以此类推。
3. java 如何递归 给树型结构的元素编号
insert tb_menu(id, name, parent) (640000000000,北京市 ,0);
insert tb_menu(id, name, parent) (640100000000,昌平区 ,1);
insert tb_menu(id, name, parent) (640101000000,霍营 ,2);
insert tb_menu(id, name, parent) (640101001000, 回龙观东大街,3);
添加一个节点属性， 根据数据不同代表的地位不同，0就代表父节点 ，1是0的子节点，2是1的子节点，以此类推。
4. java中如何建立一个java树，请详解
importjava.awt.*;
importjavax.swing.*;
classTreeDemoextendsJFrame
{
publicTreeDemo()
{
setSize(400,300);
setTitle("演示怎样使用JTree");
show();
JScrollPanejPanel=newJScrollPane();
getContentPane().add(jPanel);
JTreejtree=newJTree();
jPanel.getViewport().add(jtree,null);
validate();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
publicclassExample5_25
{
publicstaticvoidmain(String[]args)
{
TreeDemoframe=newTreeDemo();
}
}
其中JScrollPane是一个带滚动条的面板类。
将对象加入到带滚动条的面板类中，在将已建的数放入到其中。
就可建立一个系统默认的树结构。
5. 如何用Java实现树形结构啊
定义一个简单的菜单类 这里是简单的示例 你可以自行扩展package entity;import java.util.ArrayList;
import java.util.List;/**
* 菜单类
* @author Administrator
*
*/
public class Menu {
/**
* 菜单标题
*/
private String title;
/**
* 子菜单的集合
*/
private List<Menu> childs;
/**
* 父菜单
*/
private Menu parent;
/**
* 构造函数 初始化标题和子菜单集合
*/
public Menu(String title) {
this();
this.title=title;
}
/**
* 构造函数 创建一个虚拟的父菜单(零级菜单) 所有的一级菜单都归属于一个虚拟的零级菜单
*
*/
public Menu() {
this.childs = new ArrayList<Menu>();
}
/**
* 获取子菜单
* @return
*/
public List<Menu> getChilds() {
return childs;
}
/**
* 获取标题
* @return
*/
public String getTitle() {
return title;
}
/**
* 获取父菜单
* @return
*/
public Menu getParent() {
return parent;
}
/**
* 添加子菜单并返回该子菜单对象
* @param child
* @return
*/
public Menu addChild(Menu child){
this.childs.add(child);
return child;
}
/**
* 设置父菜单
* @param parent
*/
public void setParent(Menu parent) {
this.parent = parent;
}
/**
* 设置标题
* @param title
*/
public void setTitle(String title) {
this.title = title;
}
} 测试package entity;
/**
* 测试类
* @author Administrator
*
*/
public class Test { /**
* @param args
*/
public static void main(String[] args) {
/**
* 创建一个虚拟的父菜单 用于存放一级菜单 menu01 和 menu02
*/
Menu root = new Menu();
/**
* 创建两个一级菜单
*/
Menu menu01 = new Menu("一级菜单01");
Menu menu02 = new Menu("一级菜单02");
/**
* 加入虚拟菜单
*/
root.addChild(menu01);
root.addChild(menu02);
/**
* 为两个一级菜单分别添加两个子菜单 并返回该子菜单 需要进一步处理的时候 才接收返回的对象 否则只要调用方法
*/
Menu menu0101 = menu01.addChild(new Menu("二级菜单0101"));
menu01.addChild(new Menu("二级菜单0102"));
menu02.addChild(new Menu("二级菜单0201"));
Menu menu0202 = menu02.addChild(new Menu("二级菜单0202"));
/**
* 添加三级菜单
*/
menu0101.addChild(new Menu("三级菜单010101"));
menu0202.addChild(new Menu("三级菜单020201"));
/**
* 打印树形结构
*/
showMenu(root);
} /**
* 递归遍历某个菜单下的菜单树
*
* @param menu
* 根菜单
*/
private static void showMenu(Menu menu) {
for (Menu child : menu.getChilds()) {
showMenu(child, 0);
}
} private static void showMenu(Menu menu, int tabNum) {
for (int i = 0; i < tabNum; i++)
System.out.print("\t");
System.out.println(menu.getTitle());
for (Menu child : menu.getChilds())
// 递归调用
showMenu(child, tabNum + 1);
}}
控制台输出结果 一级菜单01 二级菜单0101
三级菜单010101
二级菜单0102一级菜单02
二级菜单0201
二级菜单0202
三级菜单020201
6. Java怎么实现输出是一个tree结构
树节点类：
packagecn.com.tree;
publicclassNode{
privateIntegerid;
privateIntegerparentId;
privateStringname;
privateStringlink;
publicIntegergetId(){
returnid;
}
publicvoidsetId(Integerid){
this.id=id;
}
publicIntegergetParentId(){
returnparentId;
}
publicvoidsetParentId(IntegerparentId){
this.parentId=parentId;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetLink(){
returnlink;
}
publicvoidsetLink(Stringlink){
this.link=link;
}
}
输出树形菜单类：
packagecn.com.tree;
importjava.util.ArrayList;
importjava.util.List;
publicclassTree{
privateStringBufferhtml=newStringBuffer();
privateList<Node>nodes;
publicTree(List<Node>nodes){
this.nodes=nodes;
}
publicStringbuildTree(){
html.append("<ul>");
for(Nodenode:nodes){
Integerid=node.getId();
if(node.getParentId()==null){
html.append(" <liid='"+id+"'>"+node.getName()+"</li>");
build(node);
}
}
html.append(" </ul>");
returnhtml.toString();
}
privatevoidbuild(Nodenode){
List<Node>children=getChildren(node);
if(!children.isEmpty()){
html.append(" <ul>");
for(Nodechild:children){
Integerid=child.getId();
html.append(" <liid='"+id+"'>"+child.getName()+"</li>");
build(child);
}
html.append(" </ul>");
}
}
privateList<Node>getChildren(Nodenode){
List<Node>children=newArrayList<Node>();
Integerid=node.getId();
for(Nodechild:nodes){
if(id.equals(child.getParentId())){
children.add(child);
}
}
returnchildren;
}
}
测试类：
packagezzj.test;
importjava.util.ArrayList;
importjava.util.List;
importcn.com.tree.Node;
importcn.com.tree.Tree;
publicclassTest{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
List<Node>nodes=newArrayList<Node>();
Nodenode1=newNode();
node1.setId(1);
node1.setName("node1");
node1.setParentId(null);
node1.setLink(null);
nodes.add(node1);
Nodenode11=newNode();
node11.setId(11);
node11.setName("node11");
node11.setParentId(1);
node11.setLink(null);
nodes.add(node11);
Nodenode111=newNode();
node111.setId(111);
node111.setName("node111");
node111.setParentId(11);
node111.setLink(null);
nodes.add(node111);
Nodenode12=newNode();
node12.setId(12);
node12.setName("node12");
node12.setParentId(1);
node12.setLink(null);
nodes.add(node12);
Nodenode2=newNode();
node2.setId(2);
node2.setName("node2");
node2.setParentId(null);
node2.setLink(null);
nodes.add(node2);
Nodenode21=newNode();
node21.setId(21);
node21.setName("node21");
node21.setParentId(2);
node21.setLink(null);
nodes.add(node21);
Nodenode3=newNode();
node3.setId(3);
node3.setName("node3");
node3.setParentId(null);
node3.setLink(null);
nodes.add(node3);
Treetree=newTree(nodes);
System.out.println(tree.buildTree());
}
}
7. java 大数据树形结构
你使用根节点?一般根节点都是接口,怎么可能实例化,一般在设计的时候这种情况是被考虑的,所以很多时候我们学习一个技术就是学习他的 接口,然后实例化他给的 各种 类.
包括以后我们工作做项目,设计的时候也是 基于 三层数据结构的, 底层DAO层就是接口
8. java怎么对树形结构进行遍历
java">import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;
public class Demo{
public static void main(String[] args) throws Exception {
TreeSet<Integer> ts = new TreeSet<Integer>();
for(int i = 0; i < 10; i++){
ts.add(new Random().nextInt(999));
}
for(Iterator<Integer> it = ts.iterator(); it.hasNext();){
System.out.println(it.next());
}
}
}
9. 树在java中的应用有哪些
首先：树与线性表、栈、队列等线性结构不同，树是一种非线性结构。一棵树只有一个根节点，如果一棵树有了多个根节点，那它已经不再是一棵树了，而是多棵树的集合，也被称为森林。
其次：java中树的应用主要有：菜单树，还有权限树，商品分类列表也是树结构。
10. 用Java实现一个树形结构，并对其进行遍历
importjava.util.Iterator;
importjava.util.Random;
importjava.util.TreeSet;
publicclassDemo{
publicstaticvoidmain(String[]args)throwsException{
TreeSet<Integer>ts=newTreeSet<Integer>();
for(inti=0;i<10;i++){
ts.add(newRandom().nextInt(999));
}
for(Iterator<Integer>it=ts.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
//上面是利用TreeSet进行简单的二叉树实现，另有遍历，当然遍历是自然顺序。
//如有需要请自行修改吧。