cn.ponfee.disjob.common.tree

类 TreeNode<T extends Serializable & Comparable<T>,A>

java.lang.Object

cn.ponfee.disjob.common.tree.PlainNode<T,A>

cn.ponfee.disjob.common.tree.TreeNode<T,A>

类型参数:

T - the node id type

A - the attachment biz object type

所有已实现的接口:

Serializable, Cloneable

public final class TreeNode<T extends Serializable & Comparable<T>,A>
extends PlainNode<T,A>

 Tree node structure

 ┌───────────────────────────┐
 │              0            │
 │        ┌─────┴─────┐      │
 │        1           2      │
 │    ┌───┴───┐   ┌───┴───┐  │
 │    3       4   5       6  │
 │  ┌─┴─┐   ┌─┘              │
 │  7   8   9                │
 └───────────────────────────┘

 上面这棵二叉树中的遍历方式：
   DFS前序遍历：0137849256
   DFS中序遍历：7381940526
   DFS后序遍历：7839415620
   BFS广度优先：0123456789
   CFS孩子优先：0123478956         (备注：教科书上没有CFS一说，是我为方便说明描述而取名的)
 

作者:

Ponfee

另请参阅:

序列化表格

字段概要

字段

限定符和类型	字段和说明
protected int	leftLeafCount
protected int	level
protected int	nodeDegree
protected NodePath<T>	path
protected int	siblingOrdinal
protected int	treeDegree
protected int	treeHeight
protected int	treeLeafCount
protected int	treeNodeCount

从类继承的字段 cn.ponfee.disjob.common.tree.PlainNode

attach, available, enabled, id, parentId

构造器概要

构造器

构造器和说明
TreeNode(T id, T parentId)
TreeNode(T id, T parentId, boolean enabled, boolean available, A attach)

方法概要

限定符和类型	方法和说明
static <T extends Serializable & Comparable<T>,A,E extends PlainNode<T,A>> TreeNode<T,A>	build(List<E> list)
static <T extends Serializable & Comparable<T>,A,E extends PlainNode<T,A>> TreeNode<T,A>	build(List<E> list, boolean buildPath, Comparator<? super TreeNode<T,A>> siblingNodesComparator) Builds root tree node from node list
<E extends TreeTrait<T,A,E>> E	convert(Function<TreeNode<T,A>,E> converter, boolean includeUnavailable)
List<FlatNode<T,A>>	flatBFS() 广度优先遍历BFS(Breath-First Search)
List<FlatNode<T,A>>	flatCFS() 按层级方式展开节点：兄弟节点相邻 子节点优先搜索CFS(Children-First Search) Should be invoking after mount(List, boolean, boolean, Comparator) Note：为了构建复杂表头，保证左侧的叶子节点必须排在右侧叶子节点前面，此处不能用广度优先搜索策略
List<FlatNode<T,A>>	flatDFS() 深度优先搜索DFS(Depth-First Search)：使用前序遍历 Should be invoking after mount(List, boolean, boolean, Comparator)
void	forEachChild(Consumer<TreeNode<T,A>> childProcessor)
TreeNode<T,A>	getNode(T id) Gets node by node id
<E extends PlainNode<T,A>> void	mount(List<E> list)
<E extends PlainNode<T,A>> void	mount(List<E> list, boolean ignoreIsolated, boolean buildPath, Comparator<? super TreeNode<T,A>> siblingNodesComparator) Mount these nodes append to this tree
void	print(Appendable output, Function<TreeNode<T,A>,CharSequence> nodeLabel)
TreeNode<T,A>	removeNode(T id) Remove node form tree
static <T extends Serializable & Comparable<T>,A> TreeNode<T,A>	root(T id) Creates single root tree node with id and parentId is null.
String	toString()
void	traverse(Consumer<TreeNode<T,A>> action) Traverses the tree, use BFS {@code Traverser.

从类继承的方法 cn.ponfee.disjob.common.tree.PlainNode

clone, equals, equalsId, hashCode

从类继承的方法 java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

字段详细资料

path

protected NodePath<T extends Serializable & Comparable<T>> path

level

protected int level

siblingOrdinal

protected int siblingOrdinal

leftLeafCount

protected int leftLeafCount

nodeDegree

protected int nodeDegree

treeDegree

protected int treeDegree

treeHeight

protected int treeHeight

treeNodeCount

protected int treeNodeCount

treeLeafCount

protected int treeLeafCount

构造器详细资料

TreeNode

public TreeNode(T id,
                T parentId)

TreeNode

public TreeNode(T id,
                T parentId,
                boolean enabled,
                boolean available,
                A attach)

方法详细资料

root

public static <T extends Serializable & Comparable<T>,A> TreeNode<T,A> root(T id)

Creates single root tree node with id and parentId is null.

类型参数:

T - the node id type

A - the attachment biz object type

参数:

id - the tree node id

返回:

single root tree node

build

public static <T extends Serializable & Comparable<T>,A,E extends PlainNode<T,A>> TreeNode<T,A> build(List<E> list)

build

public static <T extends Serializable & Comparable<T>,A,E extends PlainNode<T,A>> TreeNode<T,A> build(List<E> list,
                                                                                                      boolean buildPath,
                                                                                                      Comparator<? super TreeNode<T,A>> siblingNodesComparator)

Builds root tree node from node list

类型参数:

T - the node id type

A - the attachment biz object type

E - the type of list node

参数:

list - the node list

buildPath - is whether build path

siblingNodesComparator - the sibling nodes comparator

返回:

root tree node

mount

public <E extends PlainNode<T,A>> void mount(List<E> list)

mount

public <E extends PlainNode<T,A>> void mount(List<E> list,
                                             boolean ignoreIsolated,
                                             boolean buildPath,
                                             Comparator<? super TreeNode<T,A>> siblingNodesComparator)

Mount these nodes append to this tree

参数:

list - 节点列表

ignoreIsolated - 是否忽略孤立的节点

buildPath - 是否构建节点路径（比较耗资源）

siblingNodesComparator - 兄弟节点间的排序比较器

getNode

public TreeNode<T,A> getNode(T id)

Gets node by node id

参数:

id - the node id

返回:

node

removeNode

public TreeNode<T,A> removeNode(T id)

Remove node form tree

参数:

id - the node id

返回:

removed node

flatDFS

public List<FlatNode<T,A>> flatDFS()

深度优先搜索DFS(Depth-First Search)：使用前序遍历

Should be invoking after mount(List, boolean, boolean, Comparator)

返回:

flat nodes with DFS

flatCFS

public List<FlatNode<T,A>> flatCFS()

 按层级方式展开节点：兄弟节点相邻
 子节点优先搜索CFS(Children-First Search)
 Should be invoking after mount(List, boolean, boolean, Comparator)
 Note：为了构建复杂表头，保证左侧的叶子节点必须排在右侧叶子节点前面，此处不能用广度优先搜索策略
 

返回:

flat nodes with CFS

flatBFS

public List<FlatNode<T,A>> flatBFS()

广度优先遍历BFS(Breath-First Search)

返回:

flat nodes with BFS

forEachChild

public void forEachChild(Consumer<TreeNode<T,A>> childProcessor)

traverse

public void traverse(Consumer<TreeNode<T,A>> action)

Traverses the tree, use BFS

   Traverser.<File>forTree(f -> f.isDirectory() ? Arrays.asList(f.listFiles()) : Collections.emptyList())
       .breadthFirst(new File("/xxx/path"))
       .forEach(f -> System.out.println(f.getName()));
 

参数:

action - the action function

另请参阅:

Traverser

convert

public <E extends TreeTrait<T,A,E>> E convert(Function<TreeNode<T,A>,E> converter,
                                              boolean includeUnavailable)

print

public void print(Appendable output,
                  Function<TreeNode<T,A>,CharSequence> nodeLabel)
           throws IOException

抛出:

IOException

toString

public String toString()

覆盖:

toString 在类中 Object