SimpleTreeNode (common-core 1.8.10 API)

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

类型参数:

E - 树节点存放的类型

所有已实现的接口:

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方法，实现深度复制

字段概要

字段
限定符和类型字段和说明

protected static int ROOT_DEPTH
根节点的层级

字段
限定符和类型	字段和说明
`protected static int`	`ROOT_DEPTH` 根节点的层级

构造器概要

构造器
构造器和说明

SimpleTreeNode(java.lang.String id)

构造器
构造器和说明
`SimpleTreeNode(java.lang.String id)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`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()`

从类继承的方法 java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

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

类 SimpleTreeNode<E>

字段概要

构造器概要

方法概要

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

字段详细资料

ROOT_DEPTH

构造器详细资料

SimpleTreeNode

方法详细资料

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