SimpleTreeNode (common-core 1.12.0 API)

java.lang.Object
- cn.featherfly.common.structure.tree.SimpleTreeNode<E>

Type Parameters:

E - 树节点存放的类型

All Implemented Interfaces:

TreeNode<E>, TreeNodeModel<TreeNode<E>>, java.lang.Cloneable
```
public class SimpleTreeNode<E>
extends java.lang.Object
implements java.lang.Cloneable, TreeNode<E>
```
树节点.
- 修改人 zhongj 构造参数已经确定必须有id，去掉setId()方法
- 修改人 zhongj 去掉childNodes的setter方法，用appendChildNodes()来代替
- 修改人 zhongj 去掉isLeafNode属性，通过childsize来判断
- 修改人 zhongj 加入clone方法，实现深度复制

Field Summary

Fields
Modifier and Type Field and Description

protected static int ROOT_DEPTH
根节点的层级

Fields
Modifier and Type	Field and Description
`protected static int`	`ROOT_DEPTH` 根节点的层级

Constructor Summary

Constructors
Constructor and Description

SimpleTreeNode(java.lang.String id)

Constructors
Constructor and Description
`SimpleTreeNode(java.lang.String id)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChildNode(TreeNode<E> childNode)` 添加子节点
`void`	`addChildNodes(java.util.List<TreeNode<E>> childNodes)` 批量添加子节点
`void`	`addChildNodes(TreeNode<E>... childNodes)` 批量添加子节点
`void`	`changeDepth(int depth)` 改变当前节点的depth，级联改变子孙节点
`TreeNode<E>`	`clone()` 返回一个复制的节点，迭代复制所有节点
`TreeNode<E>`	`cloneAsRoot()` 复制节点并改变为根节点
`void`	`each(NodeExecutor<TreeNode<E>> executor)` 该节点及其所有子节点使用传入执行器进行操作深度优先
`boolean`	`equals(java.lang.Object object)`
`TreeNode<E>`	`findProgeny(java.lang.String progenyId)` 从子孙节点中找到指定id的节点,并将其返回
`TreeNode<E>`	`findProgeny(TreeNode<E> progeny)` 从子孙节点中找到指定节点,并将其返回.
`TreeNode<E>`	`findTreeNode(java.lang.String nodeId)` 从子孙节点中找到指定id的节点，并将其返回（包含自身）
`TreeNode<E>`	`findTreeNode(TreeNode<E> node)` 从子孙节点中找到指定节点，并将其返回（包含自身）
`TreeNode<E>`	`findTreeNode(TreeNodeMatcher<TreeNode<E>> matcher)` 从子孙节点中找到第一个匹配的节点，并将其返回（包含自身）
`java.util.List<TreeNode<E>>`	`getAncestors()` 返回当前节点的所有祖先节点.
`java.util.List<TreeNode<E>>`	`getChildNodes()` 返回直属下级
`int`	`getChildSize()` 返回子节点的数量
`int`	`getDepth()` 返回depth
`java.util.List<TreeNode<E>>`	`getEveryNode()` 返回该节点及其所有子孙节点（包含该节点）
`TreeNode<E>`	`getFirstChild()` 返回第一个子节点
`java.lang.String`	`getId()` 获取唯一标识
`TreeNode<E>`	`getLastChild()` 返回最后一个子节点
`TreeNode<E>`	`getNextSibling()` 返回相邻的下一个节点
`E`	`getNodeObject()` 返回nodeObject
`TreeNode<E>`	`getParent()` 返回上级
`int`	`getPosition()` 返回自己的位置
`TreeNode<E>`	`getPreviousSibling()` 返回相邻的上一个节点
`java.util.List<TreeNode<E>>`	`getProgenys()` 返回该节点下的所有子孙节点（包含下级的下级，不包含该节点）.
`boolean`	`hasAncestor(TreeNode<E> ancestor)` 判断传入节点是否是当前节点的祖先节点，等价`TreeNodeModel.isProgeny(TreeNodeModel)`.
`boolean`	`hasChildNode(TreeNode<E> childNode)` 返回传入节点是否是当前节点的子节点，等价`TreeNodeModel.isParent(TreeNodeModel)`.
`int`	`hashCode()`
`boolean`	`hasProgeny(TreeNode<E> progeny)` 判断传入节点是否是当前节点的后裔，等价`TreeNodeModel.isAncestor(TreeNodeModel)`.
`int`	`indexOf(TreeNode<E> childNode)` 返回指定子节点的序列值(index)
`void`	`insertChildNode(TreeNode<E> childNode, int index)` 在指定位置插入子节点
`void`	`insertChildNodeAfter(TreeNode<E> childNode, TreeNode<E> refChildNode)` 在指定节点(refChildNode)之前插入(insertChildNode) 如果找不到refChildNode就插入在最后
`void`	`insertChildNodeBefore(TreeNode<E> childNode, TreeNode<E> refChildNode)` 在指定节点(refChildNode)之前插入(insertChildNode) 如果找不到refChildNode就插入在最后
`boolean`	`isAncestor(TreeNode<E> progeny)` 判断当前节点是否是传入节点的祖先节点，等价`TreeNodeModel.hasProgeny(TreeNodeModel)`.
`boolean`	`isChildNode(TreeNode<E> parentNode)` 判断当前节点是否是传入节点的子节点
`boolean`	`isFirst()` 当前节点是否是第一个节点.
`boolean`	`isLast()` 当前节点是否是最后一个节点.
`boolean`	`isLeaf()` 返回是否是叶节点(没有子节点)
`boolean`	`isParent(TreeNode<E> childNode)` 返回当前节点是否是传入节点的父节点，等价`TreeNodeModel.hasChildNode(TreeNodeModel)`.
`boolean`	`isProgeny(TreeNode<E> ancestor)` 判断当前节点是否是传入节点的后裔，等价`TreeNodeModel.hasAncestor(TreeNodeModel)`.
`boolean`	`isRoot()` 返回是否是根
`void`	`mergeChild(TreeNode<E> child)` 如果传入节点存在，替换节点，不存在就添加
`void`	`remove()` 将当前节点从其父节点移出
`void`	`removeChildNode(TreeNode<E> childNode)` 移出子节点
`void`	`removeChildNodes()` 移出所有子节点
`void`	`replaceChild(TreeNode<E> newChild, TreeNode<E> oldChild)` 替换指定节点
`void`	`setNodeObject(E nodeObject)` 设置节点存放的对象
`void`	`setParentNode(TreeNode<E> parentNode)` 设置parentNode
`void`	`sort(java.util.Comparator<TreeNode<E>> comparator)` 通过传入的指定比较器对该节点的子节点进行排序
`void`	`sort(java.util.Comparator<TreeNode<E>> comparator, boolean containProgeny)` 通过传入的指定比较器对该节点的子节点进行排序.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ROOT_DEPTH
```
protected static final int ROOT_DEPTH
```
    根节点的层级
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SimpleTreeNode
```
public SimpleTreeNode(java.lang.String id)
```
    Parameters:
    
    id - 节点ID
- Method Detail
  - getAncestors
```
public java.util.List<TreeNode<E>> getAncestors()
```
    返回当前节点的所有祖先节点. 即父节点，父节点的父节点...一直到根节点. 顺序为最开始为父节点，最后的为根节点.
    
    Specified by:
    
    getAncestors in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    当前节点的所有祖先节点
  - hasAncestor
```
public boolean hasAncestor(TreeNode<E> ancestor)
```
    判断传入节点是否是当前节点的祖先节点，等价TreeNodeModel.isProgeny(TreeNodeModel). 即父节点，父节点的父节点...一直到根节点
    
    Specified by:
    
    hasAncestor in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    ancestor - 查找节点
    
    Returns:
    
    传入节点是否是当前节点的祖先节点
  - isProgeny
```
public boolean isProgeny(TreeNode<E> ancestor)
```
    判断当前节点是否是传入节点的后裔，等价TreeNodeModel.hasAncestor(TreeNodeModel). 即子节点，子节点的子节点....遍历整个节点树
    
    Specified by:
    
    isProgeny in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    ancestor - 查找节点
    
    Returns:
    
    当前节点是否是传入节点的后裔
  - getEveryNode
```
public java.util.List<TreeNode<E>> getEveryNode()
```
    返回该节点及其所有子孙节点（包含该节点）
    
    Specified by:
    
    getEveryNode in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    该节点及其所有子孙节点（包含该节点）
  - getProgenys
```
public java.util.List<TreeNode<E>> getProgenys()
```
    返回该节点下的所有子孙节点（包含下级的下级，不包含该节点）.
    
    Specified by:
    
    getProgenys in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    该节点下的所有子孙节点（包含下级的下级，不包含该节点）
  - hasProgeny
```
public boolean hasProgeny(TreeNode<E> progeny)
```
    判断传入节点是否是当前节点的后裔，等价TreeNodeModel.isAncestor(TreeNodeModel). 即子节点，子节点的子节点....遍历整个节点树
    
    Specified by:
    
    hasProgeny in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    progeny - 查找节点
    
    Returns:
    
    传入节点是否是当前节点的后裔
  - isAncestor
```
public boolean isAncestor(TreeNode<E> progeny)
```
    判断当前节点是否是传入节点的祖先节点，等价TreeNodeModel.hasProgeny(TreeNodeModel). 即父节点，父节点的父节点...一直到根节点
    
    Specified by:
    
    isAncestor in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    progeny - 查找节点
    
    Returns:
    
    当前节点是否是传入节点的祖先节点
  - findProgeny
```
public TreeNode<E> findProgeny(TreeNode<E> progeny)
```
    从子孙节点中找到指定节点,并将其返回.
    
    Specified by:
    
    findProgeny in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    progeny - 查找节点
    
    Returns:
    
    子孙节点中与传入节点相同的节点
  - findProgeny
```
public TreeNode<E> findProgeny(java.lang.String progenyId)
```
    从子孙节点中找到指定id的节点,并将其返回
    
    Specified by:
    
    findProgeny in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    progenyId - 查找节点ID
    
    Returns:
    
    子孙节点中与传入节点ID相同的节点
  - findTreeNode
```
public TreeNode<E> findTreeNode(TreeNodeMatcher<TreeNode<E>> matcher)
```
    从子孙节点中找到第一个匹配的节点，并将其返回（包含自身）
    
    Specified by:
    
    findTreeNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    matcher - 匹配器
    
    Returns:
    
    自身节点以及子孙节点中第一个匹配的节点
  - findTreeNode
```
public TreeNode<E> findTreeNode(TreeNode<E> node)
```
    从子孙节点中找到指定节点，并将其返回（包含自身）
    
    Specified by:
    
    findTreeNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    node - 查找节点
    
    Returns:
    
    自身节点以及子孙节点中与传入节点相同的节点
  - findTreeNode
```
public TreeNode<E> findTreeNode(java.lang.String nodeId)
```
    从子孙节点中找到指定id的节点，并将其返回（包含自身）
    
    Specified by:
    
    findTreeNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    nodeId - 超找节点ID
    
    Returns:
    
    自身节点以及子孙节点中与传入节点ID相同的节点
  - each
```
public void each(NodeExecutor<TreeNode<E>> executor)
```
    该节点及其所有子节点使用传入执行器进行操作深度优先
    
    Specified by:
    
    each in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    executor - 执行器
  - changeDepth
```
public void changeDepth(int depth)
```
    改变当前节点的depth，级联改变子孙节点
    
    Parameters:
    
    depth - 层级
  - indexOf
```
public int indexOf(TreeNode<E> childNode)
```
    返回指定子节点的序列值(index)
    
    Specified by:
    
    indexOf in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    Returns:
    
    指定子节点的序列值(index)
  - getPosition
```
public int getPosition()
```
    返回自己的位置
    
    Specified by:
    
    getPosition in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    自己的位置
  - hasChildNode
```
public boolean hasChildNode(TreeNode<E> childNode)
```
    返回传入节点是否是当前节点的子节点，等价TreeNodeModel.isParent(TreeNodeModel).
    
    Specified by:
    
    hasChildNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    Returns:
    
    是否是当前节点的子节点
  - isParent
```
public boolean isParent(TreeNode<E> childNode)
```
    返回当前节点是否是传入节点的父节点，等价TreeNodeModel.hasChildNode(TreeNodeModel).
    
    Specified by:
    
    isParent in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    Returns:
    
    当前节点是否是传入节点的父节点
  - isChildNode
```
public boolean isChildNode(TreeNode<E> parentNode)
```
    判断当前节点是否是传入节点的子节点
    
    Specified by:
    
    isChildNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    parentNode - 父节点
    
    Returns:
    
    判断当前节点是否是传入节点的子节点
  - getChildSize
```
public int getChildSize()
```
    返回子节点的数量
    
    Specified by:
    
    getChildSize in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    子节点的数量
  - addChildNode
```
public void addChildNode(TreeNode<E> childNode)
```
    添加子节点
    
    Specified by:
    
    addChildNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
  - addChildNodes
```
public void addChildNodes(TreeNode<E>... childNodes)
```
    批量添加子节点
    
    Specified by:
    
    addChildNodes in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNodes - 子节点
  - addChildNodes
```
public void addChildNodes(java.util.List<TreeNode<E>> childNodes)
```
    批量添加子节点
    
    Specified by:
    
    addChildNodes in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNodes - 子节点
  - insertChildNode
```
public void insertChildNode(TreeNode<E> childNode,
                            int index)
```
    在指定位置插入子节点
    
    Specified by:
    
    insertChildNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    index - 插入位置
  - insertChildNodeBefore
```
public void insertChildNodeBefore(TreeNode<E> childNode,
                                  TreeNode<E> refChildNode)
```
    在指定节点(refChildNode)之前插入(insertChildNode) 如果找不到refChildNode就插入在最后
    
    Specified by:
    
    insertChildNodeBefore in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    refChildNode - 插入参考节点
  - insertChildNodeAfter
```
public void insertChildNodeAfter(TreeNode<E> childNode,
                                 TreeNode<E> refChildNode)
```
    在指定节点(refChildNode)之前插入(insertChildNode) 如果找不到refChildNode就插入在最后
    
    Specified by:
    
    insertChildNodeAfter in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
    
    refChildNode - 插入参考节点
  - removeChildNode
```
public void removeChildNode(TreeNode<E> childNode)
```
    移出子节点
    
    Specified by:
    
    removeChildNode in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    childNode - 子节点
  - removeChildNodes
```
public void removeChildNodes()
```
    移出所有子节点
    
    Specified by:
    
    removeChildNodes in interface TreeNodeModel<TreeNode<E>>
  - replaceChild
```
public void replaceChild(TreeNode<E> newChild,
                         TreeNode<E> oldChild)
```
    替换指定节点
    
    Specified by:
    
    replaceChild in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    newChild - 新节点
    
    oldChild - 待替换节点
  - mergeChild
```
public void mergeChild(TreeNode<E> child)
```
    如果传入节点存在，替换节点，不存在就添加
    
    Specified by:
    
    mergeChild in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    child - 子节点
  - remove
```
public void remove()
```
    将当前节点从其父节点移出
    
    Specified by:
    
    remove in interface TreeNodeModel<TreeNode<E>>
  - getFirstChild
```
public TreeNode<E> getFirstChild()
```
    返回第一个子节点
    
    Specified by:
    
    getFirstChild in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    第一个子节点，没有子节点返回null
  - getLastChild
```
public TreeNode<E> getLastChild()
```
    返回最后一个子节点
    
    Specified by:
    
    getLastChild in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    最后一个子节点，没有子节点返回null
  - getNextSibling
```
public TreeNode<E> getNextSibling()
```
    返回相邻的下一个节点
    
    Specified by:
    
    getNextSibling in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    没有相邻的下一个节点返回null
  - getPreviousSibling
```
public TreeNode<E> getPreviousSibling()
```
    返回相邻的上一个节点
    
    Specified by:
    
    getPreviousSibling in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    没有相邻的上一个节点返回null;
  - isFirst
```
public boolean isFirst()
```
    当前节点是否是第一个节点. 只有当前一个节点时,返回true
    
    Specified by:
    
    isFirst in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    当前节点是否是第一个节点
  - isLast
```
public boolean isLast()
```
    当前节点是否是最后一个节点. 只有当前一个节点时,返回true
    
    Specified by:
    
    isLast in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    当前节点是否是最后一个节点
  - sort
```
public void sort(java.util.Comparator<TreeNode<E>> comparator)
```
    通过传入的指定比较器对该节点的子节点进行排序
    
    Specified by:
    
    sort in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    comparator - 比较器
  - sort
```
public void sort(java.util.Comparator<TreeNode<E>> comparator,
                 boolean containProgeny)
```
    通过传入的指定比较器对该节点的子节点进行排序. 如果containProgeny为真会排序所有子孙节点（子节点的子节点）
    
    Specified by:
    
    sort in interface TreeNodeModel<TreeNode<E>>
    
    Parameters:
    
    comparator - 比较器
    
    containProgeny - 是否包含子孙节点
  - clone
```
public TreeNode<E> clone()
```
    返回一个复制的节点，迭代复制所有节点
    
    Specified by:
    
    clone in interface TreeNodeModel<TreeNode<E>>
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    
    复制的节点
  - cloneAsRoot
```
public TreeNode<E> cloneAsRoot()
```
    复制节点并改变为根节点
    
    Specified by:
    
    cloneAsRoot in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    复制的对象
  - equals
```
public boolean equals(java.lang.Object object)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getNodeObject
```
public E getNodeObject()
```
    返回nodeObject
    
    Specified by:
    
    getNodeObject in interface TreeNode<E>
    
    Returns:
    
    nodeObject
  - setNodeObject
```
public void setNodeObject(E nodeObject)
```
    设置节点存放的对象
    
    Specified by:
    
    setNodeObject in interface TreeNode<E>
    
    Parameters:
    
    nodeObject - 对象
  - isRoot
```
public boolean isRoot()
```
    返回是否是根
    
    Specified by:
    
    isRoot in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    是否是跟
  - isLeaf
```
public boolean isLeaf()
```
    返回是否是叶节点(没有子节点)
    
    Specified by:
    
    isLeaf in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    是否是叶节点
  - getChildNodes
```
public java.util.List<TreeNode<E>> getChildNodes()
```
    返回直属下级
    
    Specified by:
    
    getChildNodes in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    直属下级
  - getDepth
```
public int getDepth()
```
    返回depth
    
    Specified by:
    
    getDepth in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    depth
  - getId
```
public java.lang.String getId()
```
    获取唯一标识
    
    Specified by:
    
    getId in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    唯一标识
  - getParent
```
public TreeNode<E> getParent()
```
    返回上级
    
    Specified by:
    
    getParent in interface TreeNodeModel<TreeNode<E>>
    
    Returns:
    
    上级
  - setParentNode
```
public void setParentNode(TreeNode<E> parentNode)
```
    设置parentNode
    
    Parameters:
    
    parentNode - parentNode

Class SimpleTreeNode<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ROOT_DEPTH

Constructor Detail

SimpleTreeNode

Method Detail

getAncestors

hasAncestor

isProgeny

getEveryNode

getProgenys

hasProgeny

isAncestor

findProgeny

findProgeny

findTreeNode

findTreeNode

findTreeNode

each

changeDepth

indexOf

getPosition

hasChildNode

isParent

isChildNode

getChildSize

addChildNode

addChildNodes

addChildNodes

insertChildNode

insertChildNodeBefore

insertChildNodeAfter

removeChildNode

removeChildNodes

replaceChild

mergeChild

remove

getFirstChild

getLastChild

getNextSibling

getPreviousSibling

isFirst

isLast

sort

sort

clone

cloneAsRoot

equals

hashCode

toString

getNodeObject

setNodeObject

isRoot

isLeaf

getChildNodes

getDepth

getId

getParent

setParentNode