一个Node实体类:
package com.design.patterns.composite;
import java.util.ArrayList;
import java.util.List;
public class Node {
// 编号
private long id;
// 标题
private String title;
// 下级列表
private List<Node> children = new ArrayList<Node>();
// 上级，顶层为null
private Node parent;
// 前一个节点
private Node prev;
// 后一个节点
private Node next;
// 当前处理的节点
private Node current;
/**
* 默认的构造器
*/
public Node() {
}
/**
* 推荐使用的构造器
*
* @param id 编号
* @param title 文本
*/
public Node(long id, String title) {
this.id = id;
this.title = title;
}
/**
* 增加一个下属。<br>
* 自动对应上级和兄弟结点
*
* @param n 被增加的节点
*/
public void addChild(Node n) {
children.add(n);
n.setParent(this);
if (current != null) {
current.next = n;
}
n.prev = current;
current = n;
}
/**
* 输出为下拉列表的方法
*
* @param selectedId 被选中的编号
* @return 下拉列表的字符串。可以直接放到<select></select>里面
*/
public String getOption(long selectedId) {
return "<option>" + toStringOption("", "", selectedId);
}
/**
* 输出为Text的方法。<br>
* 应网友建议，更改toString为toStringText方法。
*
* @param lftStr 左侧额外的字符串
* @param append 右侧显示的字符串
* @return 文本形式的字符串
*/
public String toStringText(String lftStr, String append) {
StringBuilder b = new StringBuilder();
b.append(append + title);
b.append(" ");
if (children.size() > 0) {
for (int i = 0; i < children.size() - 1; i++) {
b.append(lftStr + children.get(i).toStringText(lftStr + "│", "├"));
}
b.append(lftStr + children.get(children.size() - 1).toStringText(lftStr + " ", "└"));
}
return b.toString();
}
public static void main(String[] args) {
Node root = new Node(0, "菜单列表");
Node f1 = new Node(1, "开始菜单");
root.addChild(f1);
Node f1_1 = new Node(11, "程序");
f1.addChild(f1_1);
Node f1_1_1 = new Node(111, "附件");
f1_1.addChild(f1_1_1);
Node f1_1_1_1 = new Node(1111, "娱乐");
f1_1_1.addChild(f1_1_1_1);
Node f1_1_1_2 = new Node(1112, "娱乐2");
f1_1_1.addChild(f1_1_1_2);
Node f1_2 = new Node(12, "辅助工具");
f1.addChild(f1_2);
Node f2 = new Node(2, "My Documents ");
root.addChild(f2);
Node f3 = new Node(3, "My Documents2 ");
root.addChild(f3);
System.out.println(root.toStringText(" ", ""));
System.out.println(root.getOption(111));
System.out.println(f1_1_1_2.getPrev().getTitle());
System.out.println(f1_1_1_2.getPrev().getParent().getTitle());
}
public List<Node> getChildren() {
return children;
}
public long getId() {
return id;
}
/**
* 得到下一个兄弟结点。
*
* @return 如果是最后一个，则返回null
*/
public Node getNext() {
return next;
}
public Node getParent() {
return parent;
}
/**
* 得到前一个兄弟结点。
*
* @return 如果是第一个，则返回null
*/
public Node getPrev() {
return prev;
}
public String getTitle() {
return title;
}
public void setId(long id) {
this.id = id;
}
public void setNext(Node next) {
this.next = next;
}
public void setParent(Node parent) {
this.parent = parent;
}
public void setPrev(Node prev) {
this.prev = prev;
}
public void setTitle(String title) {
this.title = title;
}
/**
* 构造下拉列表.
*
* @param lftStr 左侧的字符
* @param append 增加的字符
* @param idSelected 被选中的编号
* @return 下拉列表字符串
*/
private String toStringOption(String lftStr, String append, long idSelected) {
StringBuilder b = new StringBuilder();
b.append(append + title + "</option>");
b.append(" ");
if (children.size() > 0) {
for (int i = 0; i < children.size() - 1; i++) {
b.append("<option value='" + children.get(i).getId() + "'" + (idSelected == children.get(i).getId() ? " selected" : "")
+ ">" + lftStr + children.get(i).toStringOption(lftStr + "│", "├", idSelected));
}
b.append("<option value='" + children.get(children.size() - 1).getId() + "'"
+ (idSelected == children.get(children.size() - 1).getId() ? " selected" : "") + ">" + lftStr
+ children.get(children.size() - 1).toStringOption(lftStr + " ", "└", idSelected));
}
return b.toString();
}
}
树形结构的构造类:
package com.design.patterns.composite;
import java.util.ArrayList;
import java.util.List;
/*
* 树形结构
*/
public class TreeNode<T> {
public T t;
private String id;
private String nodeName;
private TreeNode<T> parent;
private List<TreeNode<T>> childrenList = new ArrayList<TreeNode<T>>();
public TreeNode(String id,String nodeName) {
// TODO Auto-generated constructor stub
this.id=id;
this.nodeName=nodeName;
}
/*
* 添加一个节点
*/
public void add(TreeNode<T> node) {
this.childrenList.add(node);
node.setParent(this);
}
/*
* 删除一个节点
*/
public void remove(TreeNode<T> node) {
childrenList.remove(node);
}
//取得孩子节点
public List<TreeNode<T>> getChildren(){
return childrenList;
}
//展示该节点下的所有孩子节点
public void showAllNodes(TreeNode<T> node){
if (node != null) {
System.out.println(node.getNodeName().toString());
for (int i = 0; i < node.childrenList.size(); i++) {
TreeNode<T> nodes=node.childrenList.get(i);
// System.out.println(nodes.getNodeName());
showAllNodes(nodes);
}
}
}
//展示该节点下的下层节点
public void showNextNodes(TreeNode<T> node){
if (node != null) {
// System.out.println(node.getNodeName().toString());
for (int i = 0; i < node.childrenList.size(); i++) {
TreeNode<T> nodes=node.childrenList.get(i);
// System.out.println(nodes.getNodeName());
if (this.id.equals(nodes.getParent().getId())) {
System.out.println(nodes.getNodeName());
}
// if (nodes.id.startsWith((this.id))&&nodes.id.length()==2) {
// System.out.println(nodes.getNodeName());
// }
// if (nodes.id.startsWith((this.id))&&nodes.id.length()==4) {
// System.out.println(nodes.getNodeName());
// }
// showNextNodes(nodes);
}
}
}
public String getNodeName() {
return nodeName;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public void setNodeName(String nodeName) {
this.nodeName = nodeName;
}
public TreeNode<T> getParent() {
return parent;
}
public void setParent(TreeNode<T> parent) {
this.parent = parent;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
一个测试类：
package com.design.patterns.composite;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
public class Tree {
TreeNode root=null;
public Tree(String id,String name) {
// TODO Auto-generated constructor stub
this.root= new TreeNode(id,name);
}
public static void main(String[] args) {
Tree tree=new Tree("0","根目录");
TreeNode nodeB=new TreeNode("01","B");
tree.root.add(nodeB);
TreeNode nodeC=new TreeNode("01_1","C");
nodeB.add(nodeC);
TreeNode nodeD=new TreeNode("01_2","D");
nodeB.add(nodeD);
TreeNode nodeF=new TreeNode("01_3","F");
nodeB.add(nodeF);
TreeNode nodeE=new TreeNode("02","E");
tree.root.add(nodeE);
// nodeC.remove(nodeD);
// TreeNode nodes =tree.root;
// nodes.showNextNodes(nodes);
nodeB.showNextNodes(nodeB);
nodeB.remove(nodeF);
List list = nodeB.getChildren();
List list2 = tree.root.getChildren();
TreeNode nodes =tree.root;
nodes.showAllNodes(nodes);
Vector v = new Vector();//是同步的，多线程情况下可以用这个，ArrayList 是非同步的，效率要比Vector高一些
//向Vector中添加元素
//使用add方法直接添加元素
v.add("Test0");
v.add("Test1");
v.add("Test0");
v.add("Test2");
v.add("Test2");
//从Vector中删除元素
v.remove("Test0"); //删除指定内容的元素
v.remove(0); //按照索引号删除元素
//获得Vector中已有元素的个数
int size = v.size();
System.out.println("size:" + size);
//遍历Vector中的元素
for(int i = 0;i < v.size();i++){
System.out.println(v.get(i));
}
}
}
相关推荐
简单java tree 比较简单的demo，无限极菜单
- 满二叉树（Full Binary Tree）：每个节点要么有两个子节点，要么没有子节点，即没有只有一个子节点的情况。 - 平衡二叉树（Balanced Binary Tree）：左右两个子树的高度差不超过1，并且每个节点都包含左子树和右...
`Tree` 类代表了一个树形结构的整体，它包含一个根节点（`TreeNode`）和一个节点列表。该类提供了以下功能： - **获取根节点**：通过 `getRootNode()` 方法返回根节点。 - **添加节点**：`addNodes(TreeNode ...
Apache Commons Collection库提供了一个Tree接口和相关的实现，如RedBlackTree和AVLTree。这些类实现了平衡二叉搜索树，保证了插入、删除和查找操作的时间复杂度为O(log n)。它们是高效的并发环境中管理有序数据的...
在Java开发中，构建部门树（Tree）是一个常见的需求，特别是在企业级应用中，用于展示组织结构或权限管理。这个项目提供了从JSP前端到Java后端的完整解决方案，非常适合初学者理解和学习，也能帮助有经验的开发者...
此示例通过`javaTree`创建了一个可动态扩展的树形结构，并将其集成到一个简单的Swing GUI中。代码主要由两部分组成：`Branch`类和`Tree`类。 #### 二、`Branch`类详解 `Branch`类负责创建树节点。它接受一个字符串...
`TreeSet`是基于红黑树（Red-Black Tree）实现的，它是一个自平衡二叉查找树，保证了插入、删除和查找操作的时间复杂度为O(log n)。`TreeSet`不允许有重复元素，并且按照自然顺序或者用户提供的比较器进行排序。你...
在Java中实现树结构，我们通常会创建一个Node类，包含数据字段和指向子节点的引用。例如： ```java public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; ...
在Java编程语言中，"Tree"通常指的是数据结构中的树形结构，这是一个非线性的数据组织方式，模拟了自然界中的树状层次关系。在Java中，我们可以使用多种方式来实现树，包括但不限于自定义类、Java集合框架中的`...
在Java编程语言中，"Tree"是一个重要的数据结构，它以树形结构组织数据，具有节点（Node）的概念，每个节点可以有零个或多个子节点。这种数据结构非常适合表示层次关系，例如文件系统、组织架构或者计算机科学中的...
java 生成 Tree.htmjava 生成 Tree.htm
根据提供的文件名 "testtree01"，这可能是一个示例项目的名称，其中可能包含了集成 jsTree 和 Java 的代码示例。这个项目可能包含了前端的 HTML、CSS、JS 文件，以及后端的 Java 类和 JSON 响应示例。你可以通过查看...
"tree.war"是一个Web应用程序归档文件，它是Java Web应用的标准部署格式。war文件包含了所有必要的资源，如JSP页面、静态文件（如CSS和JavaScript）、图片以及WEB-INF目录下的配置文件（如web.xml）。你可以将此war...
标题中的"SR-tree-java.zip_java tree_sr tree_tree"暗示了这是一个关于Java实现的SR树（Suffix-Radix Tree）的项目。SR树是一种高效的多维数据结构，常用于数据库索引和空间数据处理，它结合了后缀树（Suffix Tree...
Java Tree Demo是一个面向Java开发者的示例项目，它展示了如何在Java中实现树形数据结构以及相关的操作。这个项目可能包含一系列的版本，从最初的基础实现到最终的完善版本，以便展示开发过程中的演变。根据描述，源...
在"BPTree2"这个文件中，我们可以期待找到一个完整的Java实现，包括B+树的节点类、插入、查找、删除等核心功能。代码应该包含了详细的注释，解释了各个部分的功能和逻辑。通过阅读和理解这段代码，开发者可以深入...
在这个"java Tree (jsp+javabean)"的项目中，开发者使用JSP（JavaServer Pages）和JavaBean技术从数据库中动态地读取数据，然后构建一个可交互的目录树视图。 JSP是一种用于创建动态网页的技术，它允许开发人员在...
以下是一个简单的树节点类的示例： ```java public class TreeNode<T> { private T data; private List<TreeNode<T>> children; public TreeNode(T data) { this.data = data; this.children = new ArrayList...
- 红黑树是一种自平衡二叉查找树，它的每个节点都有一个颜色属性，可以是红色或黑色。通过特定的规则保持树的平衡，确保操作效率。 3. `java.awt.tree.TreeModel`： - TreeModel是抽象类，定义了树数据模型的接口...