模块 java.desktop
包 javax.swing.tree

类 DefaultMutableTreeNode

java.lang.Object
javax.swing.tree.DefaultMutableTreeNode
所有已实现的接口：
Serializable , Cloneable , MutableTreeNode , TreeNode
已知子类：
JTree.DynamicUtilTreeNode
public class DefaultMutableTreeNode extends Object implements Cloneable , MutableTreeNode , Serializable
DefaultMutableTreeNode 是树数据结构中的通用节点。有关使用默认可变树节点的示例，请参阅 The Java Tutorial. 中的 如何使用树木

树节点最多可以有一个父节点和 0 个或多个子节点。 DefaultMutableTreeNode 提供检查和修改节点的父节点和子节点的操作，以及检查节点所属的树的操作。一个节点的树是所有节点的集合，可以通过从该节点开始并遵循所有可能的父节点和子节点的链接来到达这些节点。没有父节点的节点是其树的根节点；没有孩子的节点是叶子。一棵树可能包含许多子树，每个节点充当其子树的根。

此类提供枚举，用于以各种顺序有效地遍历树或子树或遵循两个节点之间的路径。 DefaultMutableTreeNode 也可能包含对用户对象的引用，该对象的使用留给用户。使用 toString() 向 DefaultMutableTreeNode 询问其字符串表示形式返回其用户对象的字符串表示形式。

这不是线程安全类。如果您打算在多个线程中使用 DefaultMutableTreeNode（或一棵 TreeNode 树），您需要自己进行同步。一个好的约定是在树的根节点上同步。

虽然 DefaultMutableTreeNode 实现了 MutableTreeNode 接口，并允许您添加 MutableTreeNode 的任何实现，但并非 DefaultMutableTreeNode 中的所有方法都适用于所有 MutableTreeNodes 实现。特别是对于提供的一些枚举，使用其中一些方法假定 DefaultMutableTreeNode 仅包含 DefaultMutableNode 实例。无论添加什么实现，所有 TreeNode/MutableTreeNode 方法都将按照定义的方式运行。

Warning: 此类的序列化对象将与未来的 Swing 版本不兼容。当前的序列化支持适用于运行相同版本 Swing 的应用程序之间的短期存储或 RMI。从 1.4 开始，对所有 JavaBeans 的长期存储的支持已添加到 java.beans 包中。请参阅 XMLEncoder 。

参见：

  • 字段详细信息

    • EMPTY_ENUMERATION

      public static final Enumeration <TreeNode > EMPTY_ENUMERATION
      始终为空的枚举。这在请求枚举叶节点的子节点时使用。

    • parent

      protected MutableTreeNode  parent
      此节点的父节点，如果此节点没有父节点则为 null

    • children

      protected Vector <TreeNode > children
      子节点数组，如果此节点没有子节点，则可能为 null

    • userObject

      protected transient Object  userObject
      可选的用户对象

    • allowsChildren

      protected boolean allowsChildren
      如果节点能够有子级，则为真

  • 构造方法详细信息

    • DefaultMutableTreeNode

      public DefaultMutableTreeNode()
      创建一个没有父节点也没有子节点但允许有子节点的树节点。

    • DefaultMutableTreeNode

      public DefaultMutableTreeNode(Object  userObject)
      创建一个没有父节点、没有子节点但允许子节点的树节点，并使用指定的用户对象对其进行初始化。
      参数：
      userObject - 构成节点数据的用户提供的对象

    • DefaultMutableTreeNode

      public DefaultMutableTreeNode(Object  userObject, boolean allowsChildren)
      创建一个没有父节点、没有子节点的树节点，用指定的用户对象初始化，并且只有在指定的情况下才允许子节点。
      参数：
      userObject - 构成节点数据的用户提供的对象
      allowsChildren - 如果为真，则该节点允许有子节点——否则，它始终是叶节点

  • 方法详情

    • insert

      public void insert(MutableTreeNode  newChild, int childIndex)
      从其当前父节点中删除 newChild（如果它有父节点），将子节点的父节点设置为该节点，然后将子节点添加到索引为 childIndex 的该节点的子节点数组。 newChild 不能为空，也不能是该节点的祖先。
      指定者：
      insert 在接口 MutableTreeNode 中
      参数：
      newChild - 要在此节点下插入的 MutableTreeNode
      childIndex - 要插入此节点的此节点的子数组中的索引
      抛出：
      ArrayIndexOutOfBoundsException - 如果 childIndex 超出范围
      IllegalArgumentException - 如果 newChild 为空或者是该节点的祖先
      IllegalStateException - 如果此节点不允许子节点
      参见：

    • remove

      public void remove(int childIndex)
      从此节点的子节点中移除指定索引处的子节点，并将该节点的父节点设置为空。要删除的子节点必须是 MutableTreeNode 。
      指定者：
      remove 在接口 MutableTreeNode 中
      参数：
      childIndex - 要移除的子节点在该节点的子数组中的索引
      抛出：
      ArrayIndexOutOfBoundsException - 如果 childIndex 超出范围

    • setParent

      public void setParent(MutableTreeNode  newParent)
      将此节点的父节点设置为 newParent 但不更改父节点的子数组。此方法从 insert() 和 remove() 调用以重新分配孩子的父母，不应从其他任何地方发送消息。
      指定者：
      setParent 在接口 MutableTreeNode 中
      参数：
      newParent - 这个节点的新父节点

    • getParent

      public TreeNode  getParent()
      返回此节点的父节点，如果此节点没有父节点，则返回 null。
      指定者：
      getParent 在接口 TreeNode 中
      返回：
      此节点的父节点 TreeNode，如果此节点没有父节点则为 null

    • getChildAt

      public TreeNode  getChildAt(int index)
      返回此节点的子数组中指定索引处的子节点。
      指定者：
      getChildAt 在接口 TreeNode 中
      参数：
      index - 此节点的子数组的索引
      返回：
      此节点的子数组中指定索引处的 TreeNode
      抛出：
      ArrayIndexOutOfBoundsException - 如果 index 超出范围

    • getChildCount

      public int getChildCount()
      返回此节点的子节点数。
      指定者：
      getChildCount 在接口 TreeNode 中
      返回：
      给出此节点的子节点数的 int

    • getIndex

      public int getIndex(TreeNode  aChild)
      返回此节点的子数组中指定子节点的索引。如果指定节点不是该节点的子节点，则返回 -1 。此方法执行线性搜索并且是 O(n)，其中 n 是孩子的数量。
      指定者：
      getIndex 在接口 TreeNode 中
      参数：
      aChild - 在此节点的子节点中搜索的 TreeNode
      返回：
      一个 int 给出该节点在该节点的子数组中的索引，或者如果指定的节点不是该节点的子节点则为 -1
      抛出：
      IllegalArgumentException - 如果 aChild 为空

    • children

      public Enumeration <TreeNode > children()
      创建并返回此节点的子节点的前向排序枚举。修改此节点的子数组会使修改前创建的任何子枚举无效。
      指定者：
      children 在接口 TreeNode 中
      返回：
      此节点的子节点的枚举

    • setAllowsChildren

      public void setAllowsChildren(boolean allows)
      确定是否允许此节点有孩子。如果allows 为假，则删除该节点的所有子节点。

      注意：默认情况下，节点允许子节点。

      参数：
      allows - 如果允许此节点有孩子，则为真

    • getAllowsChildren

      public boolean getAllowsChildren()
      如果允许此节点有子级，则返回 true。
      指定者：
      getAllowsChildren 在接口 TreeNode 中
      返回：
      如果此节点允许子节点，则为 true，否则为 false

    • setUserObject

      public void setUserObject(Object  userObject)
      将此节点的用户对象设置为 userObject 。
      指定者：
      setUserObject 在接口 MutableTreeNode 中
      参数：
      userObject - 构成此节点的用户指定数据的对象
      参见：

    • getUserObject

      public Object  getUserObject()
      返回此节点的用户对象。
      返回：
      用户存储在该节点的对象
      参见：

    • removeFromParent

      public void removeFromParent()
      从树中移除以此节点为根的子树，为该节点提供一个空父节点。如果此节点是其树的根，则不执行任何操作。
      指定者：
      removeFromParent 在接口 MutableTreeNode 中

    • remove

      public void remove(MutableTreeNode  aChild)
      从此节点的子数组中删除 aChild，为其提供一个空父节点。
      指定者：
      remove 在接口 MutableTreeNode 中
      参数：
      aChild - 要删除的此节点的子节点
      抛出：
      IllegalArgumentException - 如果 aChild 为空或不是此节点的子节点

    • removeAllChildren

      public void removeAllChildren()
      删除该节点的所有子节点，将其父节点设置为空。如果此节点没有子节点，则此方法不执行任何操作。

    • add

      public void add(MutableTreeNode  newChild)
      从其父节点中删除 newChild 并通过将其添加到该节点的子数组末尾使其成为该节点的子节点。
      参数：
      newChild - 添加为该节点子节点的节点
      抛出：
      IllegalArgumentException - 如果 newChild 为空
      IllegalStateException - 如果此节点不允许子节点
      参见：

    • isNodeAncestor

      public boolean isNodeAncestor(TreeNode  anotherNode)
      如果 anotherNode 是该节点的祖先——如果它是该节点、该节点的父节点或该节点父节点的祖先，则返回 true。 （请注意，节点被视为其自身的祖先。）如果 anotherNode 为 null，则此方法返回 false。此操作在最坏的情况下为 O(h)，其中 h 是从根到该节点的距离。
      参数：
      anotherNode - 作为该节点的祖先进行测试的节点
      返回：
      如果此节点是 anotherNode 的后代，则为真
      参见：

    • isNodeDescendant

      public boolean isNodeDescendant(DefaultMutableTreeNode  anotherNode)
      如果 anotherNode 是此节点的后代——如果它是此节点、此节点的子节点之一或此节点的子节点之一的后代，则返回 true。请注意，节点被视为其自身的后代。如果 anotherNode 为 null，则返回 false。此操作在最坏的情况下为 O(h)，其中 h 是从根到 anotherNode 的距离。
      参数：
      anotherNode - 作为该节点的后代进行测试的节点
      返回：
      如果此节点是 anotherNode 的祖先，则为真
      参见：

    • getSharedAncestor

      public TreeNode  getSharedAncestor(DefaultMutableTreeNode  aNode)
      返回此节点和 aNode 最近的共同祖先。如果不存在这样的祖先，则返回 null——如果此节点和 aNode 在不同的树中，或者如果 aNode 为 null。一个节点被认为是它自己的祖先。
      参数：
      aNode - 寻找共同祖先的节点
      返回：
      此节点和 aNode 共有的最近祖先，如果没有则为 null
      参见：

    • isNodeRelated

      public boolean isNodeRelated(DefaultMutableTreeNode  aNode)
      当且仅当 aNode 与此节点在同一棵树中时才返回 true。如果 aNode 为 null，则返回 false。
      参数：
      aNode - 寻找共同祖先的节点
      返回：
      如果 aNode 与此节点在同一棵树中，则为真；如果 aNode 为空则为假
      参见：

    • getDepth

      public int getDepth()
      返回以该节点为根的树的深度——从该节点到叶子的最长距离。如果此节点没有子节点，则返回 0。此操作比 getLevel() 昂贵得多，因为它必须有效地遍历以该节点为根的整棵树。
      返回：
      以该节点为根的树的深度
      参见：

    • getLevel

      public int getLevel()
      返回此节点上方的层数——从根到此节点的距离。如果此节点是根节点，则返回 0。
      返回：
      此节点上方的级别数
      参见：

    • getPath

      public TreeNode [] getPath()
      返回从根到该节点的路径。路径中的最后一个元素是此节点。
      返回：
      给出路径的 TreeNode 对象数组，其中路径中的第一个元素是根，最后一个元素是此节点。

    • getPathToRoot

      protected TreeNode [] getPathToRoot(TreeNode  aNode, int depth)
      构建节点的父节点，直至并包括根节点，其中原始节点是返回数组中的最后一个元素。返回数组的长度给出节点在树中的深度。
      参数：
      aNode - 获取路径的 TreeNode
      depth - 一个 int，给出已向根执行的步数（在递归调用中），用于调整返回数组的大小
      返回：
      给出从根到指定节点的路径的 TreeNodes 数组

    • getUserObjectPath

      public Object [] getUserObjectPath()
      返回从根到该节点的用户对象路径。如果路径中的某些 TreeNode 具有空用户对象，则返回的路径将包含空值。
      返回：
      从根节点到该节点的用户对象路径

    • getRoot

      public TreeNode  getRoot()
      返回包含此节点的树的根。根是父级为空的祖先。
      返回：
      包含此节点的树的根
      参见：

    • isRoot

      public boolean isRoot()
      如果此节点是树的根，则返回 true。根是树中唯一父节点为空的节点；每棵树只有一个根。
      返回：
      如果此节点是其树的根，则为真

    • getNextNode

      public DefaultMutableTreeNode  getNextNode()
      返回在此节点树的先序遍历中跟随此节点的节点。如果此节点是遍历的最后一个节点，则返回 null。这是一种遍历整棵树的低效方法；而是使用枚举。
      返回：
      在先序遍历中跟随此节点的节点，如果此节点是最后一个，则为 null
      参见：

    • getPreviousNode

      public DefaultMutableTreeNode  getPreviousNode()
      返回在此节点树的先序遍历中位于此节点之前的节点。如果此节点是遍历的第一个节点——树的根，则返回 null。这是一种遍历整棵树的低效方法；而是使用枚举。
      返回：
      前序遍历中此节点之前的节点，如果此节点是第一个，则为 null
      参见：

    • preorderEnumeration

      public Enumeration <TreeNode > preorderEnumeration()
      创建并返回一个枚举，该枚举按顺序遍历以此节点为根的子树。枚举的 nextElement() 方法返回的第一个节点就是这个节点。

      通过插入、删除或移动节点来修改树会使修改之前创建的任何枚举无效。

      返回：
      按顺序遍历树的枚举
      参见：

    • postorderEnumeration

      public Enumeration <TreeNode > postorderEnumeration()
      创建并返回一个枚举，该枚举按后序遍历以此节点为根的子树。枚举的 nextElement() 方法返回的第一个节点是最左边的叶子。这与深度优先遍历相同。

      通过插入、删除或移动节点来修改树会使修改之前创建的任何枚举无效。

      返回：
      后序遍历树的枚举
      参见：

    • breadthFirstEnumeration

      public Enumeration <TreeNode > breadthFirstEnumeration()
      创建并返回一个枚举，该枚举以广度优先顺序遍历以该节点为根的子树。枚举的 nextElement() 方法返回的第一个节点就是这个节点。

      通过插入、删除或移动节点来修改树会使修改之前创建的任何枚举无效。

      返回：
      以广度优先顺序遍历树的枚举
      参见：

    • depthFirstEnumeration

      public Enumeration <TreeNode > depthFirstEnumeration()
      创建并返回一个枚举，该枚举以深度优先顺序遍历以该节点为根的子树。枚举的 nextElement() 方法返回的第一个节点是最左边的叶子。这与后序遍历相同。

      通过插入、删除或移动节点来修改树会使修改之前创建的任何枚举无效。

      返回：
      以深度优先顺序遍历树的枚举
      参见：

    • pathFromAncestorEnumeration

      public Enumeration <TreeNode > pathFromAncestorEnumeration(TreeNode  ancestor)
      创建并返回一个枚举，该枚举遵循从 ancestor 到此节点的路径。枚举的 nextElement() 方法首先返回 ancestor ，然后是该节点的祖先 ancestor 的子节点，依此类推，最后返回该节点。枚举的创建是 O(m)，其中 m 是此节点与 ancestor 之间的节点数，包括在内。每个 nextElement() 消息都是 O(1)。

      通过插入、删除或移动节点来修改树会使修改之前创建的任何枚举无效。

      参数：
      ancestor - 从中开始枚举的节点
      返回：
      一个枚举，用于跟踪从该节点的祖先到该节点的路径
      抛出：
      IllegalArgumentException - 如果 ancestor 不是该节点的祖先
      参见：

    • isNodeChild

      public boolean isNodeChild(TreeNode  aNode)
      如果 aNode 是此节点的子节点，则返回 true。如果 aNode 为 null，则此方法返回 false。
      参数：
      aNode - 判断是否为子节点的节点
      返回：
      如果 aNode 是该节点的子节点，则为真；如果 aNode 为空则为假

    • getFirstChild

      public TreeNode  getFirstChild()
      返回此节点的第一个子级。如果此节点没有子节点，则抛出 NoSuchElementException。
      返回：
      这个节点的第一个子级
      抛出：
      NoSuchElementException - 如果这个节点没有孩子

    • getLastChild

      public TreeNode  getLastChild()
      返回此节点的最后一个子节点。如果此节点没有子节点，则抛出 NoSuchElementException。
      返回：
      这个节点的最后一个子级
      抛出：
      NoSuchElementException - 如果这个节点没有孩子

    • getChildAfter

      public TreeNode  getChildAfter(TreeNode  aChild)
      返回此节点的子数组中紧跟在 aChild 之后的子节点，它必须是此节点的子节点。如果 aChild 是最后一个孩子，则返回 null。此方法对该节点的子节点执行线性搜索以查找 aChild 并且是 O(n)，其中 n 是子节点的数量；要遍历整个子数组，请改用枚举。
      参数：
      aChild - 在它之后寻找下一个子节点的子节点
      返回：
      紧随 aChild 的此节点的子节点
      抛出：
      IllegalArgumentException - 如果 aChild 为空或不是此节点的子节点
      参见：

    • getChildBefore

      public TreeNode  getChildBefore(TreeNode  aChild)
      返回此节点的子数组中紧接在 aChild 之前的子节点，它必须是此节点的子节点。如果 aChild 是第一个孩子，则返回 null。此方法针对 aChild 执行此节点的子节点的线性搜索，并且是 O(n)，其中 n 是子节点的数量。
      参数：
      aChild - 在它之前查找上一个子节点的子节点
      返回：
      此节点紧接在 aChild 之前的子节点
      抛出：
      IllegalArgumentException - 如果 aChild 为空或不是此节点的子节点

    • isNodeSibling

      public boolean isNodeSibling(TreeNode  anotherNode)
      如果 anotherNode 是此节点的兄弟节点（具有相同的父节点），则返回 true。一个节点是它自己的兄弟节点。如果 anotherNode 为 null，则返回 false。
      参数：
      anotherNode - 作为该节点的兄弟节点进行测试的节点
      返回：
      如果 anotherNode 是该节点的兄弟节点则为真

    • getSiblingCount

      public int getSiblingCount()
      返回此节点的兄弟节点数。一个节点是它自己的兄弟节点（如果它没有父节点或没有兄弟节点，则此方法返回 1 ）。
      返回：
      此节点的兄弟节点数

    • getNextSibling

      public DefaultMutableTreeNode  getNextSibling()
      返回父节点的子节点数组中此节点的下一个兄弟节点。如果此节点没有父节点或者是父节点的最后一个子节点，则返回 null。此方法执行 O(n) 的线性搜索，其中 n 是子级的数量；要遍历整个数组，请改用父项的子项枚举。
      返回：
      紧跟在该节点之后的该节点的兄弟节点
      参见：

    • getPreviousSibling

      public DefaultMutableTreeNode  getPreviousSibling()
      返回父节点的子节点数组中此节点的前一个兄弟节点。如果此节点没有父节点或者是父节点的第一个子节点，则返回 null。此方法执行 O(n) 线性搜索，其中 n 是子级的数量。
      返回：
      紧接在该节点之前的该节点的兄弟节点

    • isLeaf

      public boolean isLeaf()
      如果此节点没有子节点，则返回 true。区分没有子级的节点和有子级的节点不能有孩子（例如区分文件和空目录），将此方法与 getAllowsChildren 结合使用
      指定者：
      isLeaf 在接口 TreeNode 中
      返回：
      如果此节点没有子节点，则为真
      参见：

    • getFirstLeaf

      public DefaultMutableTreeNode  getFirstLeaf()
      查找并返回作为此节点后代的第一个叶子——此节点或其第一个子节点的第一个叶子。如果它是叶子，则返回此节点。
      返回：
      以此节点为根的子树中的第一个叶子
      参见：

    • getLastLeaf

      public DefaultMutableTreeNode  getLastLeaf()
      查找并返回作为此节点后代的最后一片叶子——此节点或其最后一个子节点的最后一片叶子。如果它是叶子，则返回此节点。
      返回：
      以此节点为根的子树中的最后一片叶子
      参见：

    • getNextLeaf

      public DefaultMutableTreeNode  getNextLeaf()
      返回此节点之后的叶子，如果此节点是树中的最后一个叶子，则返回 null。

      在MutableNode接口的这个实现中，这个操作是非常低效的。为了确定下一个节点，此方法首先在父节点的子列表中执行线性搜索以找到当前节点。

      该实现使该操作适用于从已知位置开始的短时间遍历。但是要遍历树中的所有叶子，您应该使用 depthFirstEnumeration 枚举树中的节点，并在每个节点上使用 isLeaf 来确定哪些是叶子。

      返回：
      返回经过该节点的下一个叶子
      参见：

    • getPreviousLeaf

      public DefaultMutableTreeNode  getPreviousLeaf()
      返回此节点之前的叶子，如果此节点是树中的第一个叶子，则返回 null。

      在MutableNode接口的这个实现中，这个操作是非常低效的。为了确定前一个节点，此方法首先在父节点的子列表中执行线性搜索以找到当前节点。

      该实现使该操作适用于从已知位置开始的短时间遍历。但是要遍历树中的所有叶子，您应该使用 depthFirstEnumeration 枚举树中的节点，并在每个节点上使用 isLeaf 来确定哪些是叶子。

      返回：
      返回此节点之前的叶子
      参见：

    • getLeafCount

      public int getLeafCount()
      返回作为此节点后代的叶子总数。如果此节点是叶子，则返回 1 。此方法是 O(n)，其中 n 是此节点的后代数。
      返回：
      此节点下的叶数
      参见：

    • toString

      public String  toString()
      返回向该节点的用户对象发送toString()的结果，如果该节点没有用户对象则返回空字符串。
      重写：
      toString 在类 Object 中
      返回：
      对象的字符串表示形式。
      参见：

    • clone

      public Object  clone()
      重写以使克隆公开。返回此节点的浅表副本；新节点没有父节点或子节点，并且具有对同一用户对象的引用（如果有的话）。
      重写：
      clone 在类 Object 中
      返回：
      此节点的副本
      参见：