Java 树节点

1.节点数据类

import java.util.HashMap;

/**
 * 节点
 * 
 * @author zhouc
 *
 */
public class NodeData extends HashMap<String, Object> {

	/**
	 * 
	 */
	private static final long serialVersionUID = 7843181045735515748L;
}

2.节点类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

/**
 * 节点
 * 
 * @author zhouc
 *
 */
public class Node {

	/**
	 * 节点ID
	 */
	private String id;

	/**
	 * 节点名称
	 */
	private String name;
	/**
	 * 父节点
	 */
	private Node parent;
	/**
	 * 子节点
	 */
	private List<Node> children;
	/**
	 * 节点数据
	 */
	private NodeData data;

	/**
	 * 未命名节点构造器
	 */
	public Node() {
		id = UUID.randomUUID().toString();
		name = "";
		this.children = new ArrayList<>();
	}

	/**
	 * 命名节点构造器
	 * 
	 * @param name
	 */
	public Node(String name) {
		id = UUID.randomUUID().toString();
		this.name = name;
		this.children = new ArrayList<>();
	}

	/**
	 * 获取节点ID
	 * 
	 * @return
	 */
	public String id() {
		return id;
	}

	/**
	 * 获取节点名称
	 * 
	 * @return
	 */
	public String name() {
		return name;
	}

	/**
	 * 设置节点名称
	 * 
	 * @param name
	 * @return
	 */
	public Node name(String name) {
		this.name = name;
		return this;
	}

	/**
	 * 获取父节点
	 * 
	 * @return
	 */
	public Node parent() {
		return parent;
	}

	/**
	 * 设置父节点
	 * 
	 * @param node 父节点，null时节点转为根节点
	 * @return 返回this
	 */
	public Node parent(Node node) {
		if (parent != null) {
			parent.removeChild(this);
		}
		if (node == null) {
			return this;
		} else {
			node.addChild(this);
		}
		return this;
	}

	/**
	 * 获取子节点
	 * 
	 * @return
	 */
	public List<Node> children() {
		return children;
	}

	/**
	 * 添加子节点
	 * 
	 * @param child
	 */
	public Node addChild(Node... nodes) {
		for (Node node : nodes) {
			node.parent = this;
			children.add(node);
		}
		return this;
	}

	/**
	 * 添加子节点
	 * 
	 * @param index
	 * @param nodes
	 * @return
	 */
	public Node addChild(int index, Node... nodes) {
		for (Node node : nodes) {
			node.parent = this;
			children.add(index++, node);
		}
		return this;
	}

	/**
	 * 删除子节点
	 * 
	 * @param nodes
	 * @return 返回被删除的节点
	 */
	public List<Node> removeChild(Node... nodes) {
		return removeChild(Arrays.asList(nodes));
	}

	/**
	 * 删除子节点
	 * 
	 * @param nodes
	 * @return 返回被删除的节点
	 */
	public List<Node> removeChild(List<Node> nodes) {
		List<Node> notRemoved = new ArrayList<>();
		List<Node> removed = new ArrayList<>();
		for (Node node : nodes) {
			if (children.remove(node)) {
				node.parent = null;
				removed.add(node);
			} else {
				notRemoved.add(node);
			}
		}
		if (!notRemoved.isEmpty()) {
			for (Node node : children) {
				removed.addAll(node.removeChild(notRemoved));
			}
		}
		return removed;
	}

	/**
	 * 删除子节点
	 * 
	 * @param id 节点ID
	 * @return 返回被删除的节点
	 */
	public Node removeChild(String id) {
		for (Node node : new ArrayList<>(children)) {
			if (id.equals(node.id)) {
				children.remove(node);
				return node;
			}
		}
		for (Node node : children) {
			return node.removeChild(id);
		}
		return null;
	}

	/**
	 * 获取节点数据
	 * 
	 * @return
	 */
	public NodeData data() {
		return data;
	}

	/**
	 * 设置节点数据
	 * 
	 * @param data
	 * @return 返回this
	 */
	public Node data(NodeData data) {
		this.data = data;
		return this;
	}

	/**
	 * 根据节点名称从节点及子节点中查找节点
	 * 
	 * @param name 节点名称
	 * @return
	 */
	public List<Node> findByName(String name) {
		List<Node> list = new ArrayList<>();
		if (name.equals(this.name)) {
			list.add(this);
		}
		for (Node node : children) {
			list.addAll(node.findByName(name));
		}
		return list;
	}

	/**
	 * 根据节点名称从节点及子节点中查找节点
	 * 
	 * @param name 节点名称
	 * @return
	 */
	public Node findById(String id) {
		if (id.equals(this.id)) {
			return this;
		}
		for (Node node : children) {
			Node n = node.findById(id);
			if (n != null) {
				return n;
			}
		}
		return null;
	}

	/**
	 * 获取根节点
	 * 
	 * @return
	 */
	public Node root() {
		if (parent == null) {
			return this;
		} else {
			return parent.root();
		}
	}

	/**
	 * 获取节点路径
	 * 
	 * @return
	 */
	public String path() {
		return (parent == null ? "" : parent.path()) + "/" + name;
	}

	@Override
	public String toString() {
		String line = "|----\t";
		String dataMark = "\tdata: ";
		StringBuffer s = new StringBuffer(line + name + "\n");
		for (Node child : children) {
			s.append(child.toString().replace(line, "\t" + line).replace(dataMark, "\t" + dataMark));
		}
		return s.toString();
	}

}

3、测试类

public class Test {
	public static void main(String[] args) {
		Node root = new Node("root");
		Node a = new Node("a"), b = new Node("b");
		Node aa = new Node("aa"), ab = new Node("ab"), ac = new Node("ac");
		Node aaa = new Node("aaa"), aab = new Node("aab");
		Node aba = new Node("aba");
		Node ba = new Node("ba");
		root.addChild(a.addChild(aa.addChild(aaa, aab), ab.addChild(aba), ac), b.addChild(ba));
		System.out.println(String.format("===================初始树===================\n%s", root));

		root.removeChild(ab);
		System.out.println(String.format("===================删除ab后的树===================\n%s", root));
		System.out.println(String.format("===================被root删除后ab所在的树===================\n%s", ab.root()));
		aa.parent(root);
		System.out.println(String.format("===================aa连接到root后的树===================\n%s", aa.root()));
		b.parent(null);
		System.out.println(String.format("===================b节点断开后的树===================\n%s", root));
		System.out.println(String.format("===================b节点断开后b所在的树===================\n%s", b.root()));

	}
}

 4、测试结果

---