模块 java.desktop
包 javax.swing

类 JTree

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JTree
所有已实现的接口：
ImageObserver , MenuContainer , Serializable , Accessible , Scrollable
@JavaBean (defaultProperty ="UI", description ="A component that displays a set of hierarchical data as an outline.") public class JTree extends JComponent implements Scrollable , Accessible
将一组分层数据显示为大纲的控件。您可以在 如何使用树木 中找到面向任务的文档和使用树的示例，这是 The Java Tutorial. 中的一个部分

树中的特定节点可以通过TreePath（封装节点及其所有祖先的对象）或通过其显示行来标识，其中显示区域中的每一行显示一个节点。一个展开node 是一个非叶节点（由 TreeModel.isLeaf(node) 返回 false 标识），当它的所有祖先都被删除时，它将显示它的子节点展开. A 倒塌节点是隐藏它们的节点。 Ahidden节点是位于折叠祖先下的节点。所有的一个可见的节点父节点被展开，但可能会或可能不会显示。 A显示节点既可见又在显示区，在那里可以看到。

以下 JTree 方法使用“可见”表示“显示”：
  • isRootVisible()
  • setRootVisible()
  • scrollPathToVisible()
  • scrollRowToVisible()
  • getVisibleRowCount()
  • setVisibleRowCount()
下一组 JTree 方法使用“可见”来表示“可见”（在展开的父项下）：
  • isVisible()
  • makeVisible()
如果您有兴趣了解选择何时更改，请实施 TreeSelectionListener 接口并使用方法 addTreeSelectionListener 添加实例。 valueChanged 将在选择更改时被调用，也就是说，如果用户在同一节点上单击两次，valueChanged 将仅被调用一次。

如果您对检测双击事件或用户单击节点感兴趣，无论它是否被选中，我们建议您执行以下操作：

 final JTree tree = ...;

 MouseListener ml = new MouseAdapter() {
   public void mousePressed(MouseEvent e) {
     int selRow = tree.getRowForLocation(e.getX(), e.getY());
     TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
     if(selRow != -1) {
       if(e.getClickCount() == 1) {
         mySingleClick(selRow, selPath);
       }
       else if(e.getClickCount() == 2) {
         myDoubleClick(selRow, selPath);
       }
     }
   }
 };
 tree.addMouseListener(ml);
注意：本例同时获取路径和行，但您只需要获取您感兴趣的那个即可。

要使用 JTree 显示复合节点（例如，包含图形图标和文本的节点），子类化 TreeCellRenderer 并使用 setCellRenderer(javax.swing.tree.TreeCellRenderer) 告诉树使用它。要编辑此类节点，子类化 TreeCellEditor 并使用 setCellEditor(javax.swing.tree.TreeCellEditor) 。

与所有 JComponent 类一样，您可以使用 InputMap 和 ActionMap 将 Action 对象与 KeyStroke 相关联，并在指定条件下执行操作。

Warning: Swing 不是线程安全的。有关详细信息，请参阅 Swing 的线程策略。

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

自从：
1.2

  • 字段详细信息

    • treeModel

      protected transient TreeModel  treeModel
      定义此对象显示的树的模型。

    • selectionModel

      protected transient TreeSelectionModel  selectionModel
      为这棵树中的选定节点集建模。

    • rootVisible

      protected boolean rootVisible
      如果显示根节点，则为 True；如果其子节点是可见的最高节点，则为 false。

    • cellRenderer

      protected transient TreeCellRenderer  cellRenderer
      用于绘制节点的单元格。如果为 null，则 UI 使用默认值 cellRenderer。

    • rowHeight

      protected int rowHeight
      用于每个显示行的高度。如果这是 <= 0，则渲染器确定每一行的高度。

    • showsRootHandles

      protected boolean showsRootHandles
      如果句柄显示在树的最顶层，则为真。

      句柄是显示在节点旁边的小图标，允许用户单击一次以展开或折叠节点。公共界面显示加号 (+) 表示可以展开的节点，减号 (-) 表示可以折叠的节点。始终显示最顶层以下节点的句柄。

      如果 rootVisible 设置指定要显示根节点，那么它是最顶层的唯一节点。如果未显示根节点，则其所有子节点都位于树的最顶层。始终显示除最顶层以外的节点的句柄。

      如果根节点不可见，通常最好将该值设置为真。否则，树看起来就像一个列表，用户可能不知道“列表条目”实际上是树节点。

      参见：

    • selectionRedirector

      protected transient JTree.TreeSelectionRedirector  selectionRedirector
      创建一个新事件并将其从 selectionListeners 传递出去。

    • cellEditor

      protected transient TreeCellEditor  cellEditor
      条目的编辑器。默认为 null（树不可编辑）。

    • editable

      protected boolean editable
      树是可编辑的吗？默认为假。

    • largeModel

      protected boolean largeModel
      这棵树是大模型吗？这是一个代码优化设置。当所有节点的单元格高度相同时，可以使用大型模型。然后 UI 将缓存非常少的信息，而是不断向模型发送消息。如果没有大型模型，UI 会缓存大部分信息，从而减少对模型的方法调用。

      此值只是对 UI 的建议。并非所有 UI 都会利用它。默认值为假。

    • visibleRowCount

      protected int visibleRowCount
      一次可见的行数。此值用于 Scrollable 接口。它决定了显示区域的首选大小。

    • invokesStopCellEditing

      protected boolean invokesStopCellEditing
      如果为真，当通过选择更改停止编辑时，调用树更改或其他方式中的数据stopCellEditing，并保存更改。如果为假，则调用 cancelCellEditing，并丢弃更改。默认为假。

    • scrollsOnExpand

      protected boolean scrollsOnExpand
      如果为 true，当一个节点被展开时，许多后代被滚动为可见。

    • toggleClickCount

      protected int toggleClickCount
      节点展开前的鼠标点击次数。

    • treeModelListener

      protected transient TreeModelListener  treeModelListener
      更新 expandedState 。

    • CELL_RENDERER_PROPERTY

      public static final String  CELL_RENDERER_PROPERTY
      cellRenderer 的绑定属性名称。
      参见：

    • TREE_MODEL_PROPERTY

      public static final String  TREE_MODEL_PROPERTY
      treeModel 的绑定属性名称。
      参见：

    • ROOT_VISIBLE_PROPERTY

      public static final String  ROOT_VISIBLE_PROPERTY
      rootVisible 的绑定属性名称。
      参见：

    • SHOWS_ROOT_HANDLES_PROPERTY

      public static final String  SHOWS_ROOT_HANDLES_PROPERTY
      showsRootHandles 的绑定属性名称。
      参见：

    • ROW_HEIGHT_PROPERTY

      public static final String  ROW_HEIGHT_PROPERTY
      rowHeight 的绑定属性名称。
      参见：

    • CELL_EDITOR_PROPERTY

      public static final String  CELL_EDITOR_PROPERTY
      cellEditor 的绑定属性名称。
      参见：

    • EDITABLE_PROPERTY

      public static final String  EDITABLE_PROPERTY
      editable 的绑定属性名称。
      参见：

    • LARGE_MODEL_PROPERTY

      public static final String  LARGE_MODEL_PROPERTY
      largeModel 的绑定属性名称。
      参见：

    • SELECTION_MODEL_PROPERTY

      public static final String  SELECTION_MODEL_PROPERTY
      selectionModel 的绑定属性名称。
      参见：

    • VISIBLE_ROW_COUNT_PROPERTY

      public static final String  VISIBLE_ROW_COUNT_PROPERTY
      visibleRowCount 的绑定属性名称。
      参见：

    • INVOKES_STOP_CELL_EDITING_PROPERTY

      public static final String  INVOKES_STOP_CELL_EDITING_PROPERTY
      messagesStopCellEditing 的绑定属性名称。
      参见：

    • SCROLLS_ON_EXPAND_PROPERTY

      public static final String  SCROLLS_ON_EXPAND_PROPERTY
      scrollsOnExpand 的绑定属性名称。
      参见：

    • TOGGLE_CLICK_COUNT_PROPERTY

      public static final String  TOGGLE_CLICK_COUNT_PROPERTY
      toggleClickCount 的绑定属性名称。
      参见：

    • LEAD_SELECTION_PATH_PROPERTY

      public static final String  LEAD_SELECTION_PATH_PROPERTY
      leadSelectionPath 的绑定属性名称。
      自从：
      1.3
      参见：

    • ANCHOR_SELECTION_PATH_PROPERTY

      public static final String  ANCHOR_SELECTION_PATH_PROPERTY
      锚点选择路径的绑定属性名称。
      自从：
      1.3
      参见：

    • EXPANDS_SELECTED_PATHS_PROPERTY

      public static final String  EXPANDS_SELECTED_PATHS_PROPERTY
      用于扩展选定路径属性的绑定属性名称
      自从：
      1.3
      参见：

  • 构造方法详细信息

    • JTree

      public JTree()
      返回带有示例模型的 JTree。树使用的默认模型将叶节点定义为没有子节点的任何节点。
      参见：

    • JTree

      public JTree(Object [] value)
      返回一个 JTree，其中指定数组的每个元素作为未显示的新根节点的子节点。默认情况下，树将叶节点定义为没有子节点的任何节点。
      参数：
      value - Object 的数组
      参见：

    • JTree

      public JTree(Vector <?> value)
      返回一个 JTree，其中指定 Vector 的每个元素作为未显示的新根节点的子节点。默认情况下，树将叶节点定义为没有子节点的任何节点。
      参数：
      value - 一个 Vector
      参见：

    • JTree

      public JTree(Hashtable <?,?> value)
      返回从 Hashtable 创建的 JTree，它不显示在 root 中。 HashTable 中键/值对的每个半值成为新根节点的子节点。默认情况下，树将叶节点定义为没有子节点的任何节点。
      参数：
      value - 一个 Hashtable
      参见：

    • JTree

      public JTree(TreeNode  root)
      返回一个以指定的TreeNode为根的JTree，显示根节点。默认情况下，树将叶节点定义为没有子节点的任何节点。
      参数：
      root - 一个 TreeNode 对象
      参见：

    • JTree

      public JTree(TreeNode  root, boolean asksAllowsChildren)
      返回一个以指定TreeNode为根的JTree，显示根节点，并以指定方式判断一个节点是否为叶节点。
      参数：
      root - 一个 TreeNode 对象
      asksAllowsChildren - 如果为假，任何没有孩子的节点都是叶节点；如果为真，则只有不允许子节点的节点才是叶节点
      参见：

    • JTree

      @ConstructorProperties ("model") public JTree(TreeModel  newModel)
      返回 JTree 的实例，它显示根节点——树是使用指定的数据模型创建的。
      参数：
      newModel - 用作数据模型的 TreeModel

  • 方法详情

    • getDefaultTreeModel

      protected static TreeModel  getDefaultTreeModel()
      创建并返回样本 TreeModel 。主要用于 beanbuilder 来展示一些有趣的东西。
      返回：
      默认TreeModel

    • createTreeModel

      protected static TreeModel  createTreeModel(Object  value)
      返回包装指定对象的 TreeModel。如果对象是：
      • Object 数组，
      • 一个 Hashtable ，或者
      • Vector
      然后创建一个新的根节点，将每个传入对象作为子节点。否则，将创建一个值为 "root" 的新根。
      参数：
      value - Object 用作 TreeModel 的基础
      返回：
      TreeModel 包装指定对象

    • getUI

      public TreeUI  getUI()
      返回呈现此组件的 L&F 对象。
      重写：
      getUI 在类 JComponent 中
      返回：
      呈现此组件的 TreeUI 对象

    • setUI

      @BeanProperty (hidden =true, visualUpdate =true, description ="The UI object that implements the Component\'s LookAndFeel.") public void setUI(TreeUI  ui)
      设置呈现此组件的 L&F 对象。

      这是绑定属性。

      参数：
      ui - TreeUI L&F 对象
      参见：

    • updateUI

      public void updateUI()
      来自 UIManager 的通知，L&F 已更改。用 UIManager 的最新版本替换当前 UI 对象。
      重写：
      updateUI 在类 JComponent 中
      参见：

    • getUIClassID

      @BeanProperty (bound =false) public String  getUIClassID()
      返回呈现此组件的 L&F 类的名称。
      重写：
      getUIClassID 在类 JComponent 中
      返回：
      字符串“TreeUI”
      参见：

    • getCellRenderer

      public TreeCellRenderer  getCellRenderer()
      返回渲染每个单元格的当前 TreeCellRenderer。
      返回：
      渲染每个单元格的 TreeCellRenderer

    • setCellRenderer

      @BeanProperty (description ="The TreeCellRenderer that will be used to draw each cell.") public void setCellRenderer(TreeCellRenderer  x)
      设置将用于绘制每个单元格的 TreeCellRenderer。

      这是绑定属性。

      参数：
      x - 用于渲染每个单元格的 TreeCellRenderer

    • setEditable

      @BeanProperty (description ="Whether the tree is editable.") public void setEditable(boolean flag)
      确定树是否可编辑。如果新设置与现有设置不同，则触发属性更改事件。

      这是绑定属性。

      参数：
      flag - 一个boolean，如果树是可编辑的则为真

    • isEditable

      public boolean isEditable()
      如果树是可编辑的，则返回 true。
      返回：
      如果树是可编辑的，则为真

    • setCellEditor

      @BeanProperty (description ="The cell editor. A null value implies the tree cannot be edited.") public void setCellEditor(TreeCellEditor  cellEditor)
      设置单元格编辑器。 null 值表示无法编辑树。如果这表示 cellEditor 发生了变化，则会对所有监听器调用 propertyChange 方法。

      这是绑定属性。

      参数：
      cellEditor - 要使用的 TreeCellEditor

    • getCellEditor

      public TreeCellEditor  getCellEditor()
      返回用于编辑树中条目的编辑器。
      返回：
      TreeCellEditor 正在使用，或者 null 如果无法编辑树

    • getModel

      public TreeModel  getModel()
      返回提供数据的 TreeModel。
      返回：
      提供数据的TreeModel

    • setModel

      @BeanProperty (description ="The TreeModel that will provide the data.") public void setModel(TreeModel  newModel)
      设置将提供数据的TreeModel。

      这是绑定属性。

      参数：
      newModel - TreeModel 即提供数据

    • isRootVisible

      public boolean isRootVisible()
      如果显示树的根节点，则返回 true。
      返回：
      如果显示树的根节点，则为真
      参见：

    • setRootVisible

      @BeanProperty (description ="Whether or not the root node from the TreeModel is visible.") public void setRootVisible(boolean rootVisible)
      确定 TreeModel 的根节点是否可见。

      这是绑定属性。

      参数：
      rootVisible - 如果要显示树的根节点则为真
      参见：

    • setShowsRootHandles

      @BeanProperty (description ="Whether the node handles are to be displayed.") public void setShowsRootHandles(boolean newValue)
      设置 showsRootHandles 属性的值，该属性指定是否应显示节点句柄。此属性的默认值取决于用于创建 JTree 的构造函数。有些外观可能不支持句柄；他们将忽略此属性。

      这是绑定属性。

      参数：
      newValue - true 是否应显示根句柄；否则，false
      参见：

    • getShowsRootHandles

      public boolean getShowsRootHandles()
      返回 showsRootHandles 属性的值。
      返回：
      showsRootHandles 属性的值
      参见：

    • setRowHeight

      @BeanProperty (description ="The height of each cell.") public void setRowHeight(int rowHeight)
      设置每个单元格的高度，以像素为单位。如果指定值小于或等于零，则查询当前单元格渲染器以获取每一行的高度。

      这是绑定属性。

      参数：
      rowHeight - 每个单元格的高度，以像素为单位

    • getRowHeight

      public int getRowHeight()
      返回每行的高度。如果返回值小于或等于 0，则每行的高度由渲染器确定。
      返回：
      每行的高度

    • isFixedRowHeight

      @BeanProperty (bound =false) public boolean isFixedRowHeight()
      如果每个显示行的高度是固定大小，则返回 true。
      返回：
      如果每行的高度是固定大小，则为真

    • setLargeModel

      @BeanProperty (description ="Whether the UI should use a large model.") public void setLargeModel(boolean newValue)
      指定 UI 是否应使用大型模型。 （并非所有 UI 都会实现这一点。）触发 LARGE_MODEL_PROPERTY 的属性更改。

      这是绑定属性。

      参数：
      newValue - 向 UI 建议大型模型时为真
      参见：

    • isLargeModel

      public boolean isLargeModel()
      如果树是为大型模型配置的，则返回 true。
      返回：
      如果建议使用大型模型，则为真
      参见：

    • setInvokesStopCellEditing

      @BeanProperty (description ="Determines what happens when editing is interrupted, selecting another node in the tree, a change in the tree\'s data, or some other means.") public void setInvokesStopCellEditing(boolean newValue)
      确定通过选择树中的另一个节点、树数据的更改或其他方式中断编辑时会发生什么。将此属性设置为 true 会导致编辑中断时自动保存更改。

      触发 INVOKES_STOP_CELL_EDITING_PROPERTY 的属性更改。

      参数：
      newValue - true表示编辑中断时调用stopCellEditing，保存数据； false 表示 cancelCellEditing 被调用，更改丢失

    • getInvokesStopCellEditing

      public boolean getInvokesStopCellEditing()
      返回指示器，指示编辑中断时发生的情况。
      返回：
      指示编辑中断时发生的情况的指示器
      参见：

    • setScrollsOnExpand

      @BeanProperty (description ="Indicates if a node descendant should be scrolled when expanded.") public void setScrollsOnExpand(boolean newValue)
      设置 scrollsOnExpand 属性，该属性确定树是否可以滚动以显示以前隐藏的子项。如果此属性为 true（默认值），则当节点展开时，树可以使用滚动来使节点后代的最大可能数量可见。在某些外观和感觉中，树在展开时可能不需要滚动；那些外观和感觉将忽略此属性。

      这是绑定属性。

      参数：
      newValue - false 禁用扩展滚动； true 启用它
      参见：

    • getScrollsOnExpand

      public boolean getScrollsOnExpand()
      返回 scrollsOnExpand 属性的值。
      返回：
      scrollsOnExpand 属性的值

    • setToggleClickCount

      @BeanProperty (description ="Number of clicks before a node will expand/collapse.") public void setToggleClickCount(int clickCount)
      设置节点展开或关闭前的鼠标点击次数。默认值为两个。

      这是绑定属性。

      参数：
      clickCount - 展开或关闭节点的鼠标点击次数
      自从：
      1.3

    • getToggleClickCount

      public int getToggleClickCount()
      返回展开或关闭节点所需的鼠标点击次数。
      返回：
      节点展开前的鼠标点击次数
      自从：
      1.3

    • setExpandsSelectedPaths

      @BeanProperty (description ="Indicates whether changes to the selection should make the parent of the path visible.") public void setExpandsSelectedPaths(boolean newValue)
      配置 expandsSelectedPaths 属性。如果为真，则任何时候通过 TreeSelectionModel 或 JTree 提供的覆盖方法更改选择， TreePath 的父级将展开以使其可见（可见意味着父路径已展开，不一定在可见矩形中JTree）。如果为 false，则当选择更改时，父节点不可见（其所有父节点都已展开）。如果您希望让您的选择模型保持不总是可见的路径（所有父级展开），这将很有用。

      这是绑定属性。

      参数：
      newValue - expandsSelectedPaths 的新值
      自从：
      1.3

    • getExpandsSelectedPaths

      public boolean getExpandsSelectedPaths()
      返回 expandsSelectedPaths 属性。
      返回：
      如果选择更改导致父路径被扩展，则为真
      自从：
      1.3
      参见：

    • setDragEnabled

      @BeanProperty (bound =false, description ="determines whether automatic drag handling is enabled") public void setDragEnabled(boolean b)
      打开或关闭自动拖动处理。为了启用自动拖动处理，此属性应设置为 true ，树的 TransferHandler 需要为 non-null 。 dragEnabled 属性的默认值为 false 。

      尊重此属性并识别用户拖动手势的工作在于外观实现，特别是树的 TreeUI 。启用自动拖动处理后，只要用户在项目上按下鼠标按钮，然后将鼠标移动几个像素，大多数外观（包括子类 BasicLookAndFeel 的外观和感觉）都会开始拖放操作。因此，将此属性设置为 true 会对选择的行为方式产生微妙的影响。

      如果使用忽略此属性的外观，您仍然可以通过在树的 TransferHandler 上调用 exportAsDrag 来开始拖放操作。

      参数：
      b - 是否启用自动拖动处理
      抛出：
      HeadlessException - 如果 b 是 true 并且 GraphicsEnvironment.isHeadless() 返回 true
      自从：
      1.4
      参见：

    • getDragEnabled

      public boolean getDragEnabled()
      返回是否启用自动拖动处理。
      返回：
      dragEnabled 属性的值
      自从：
      1.4
      参见：

    • setDropMode

      public final void setDropMode(DropMode  dropMode)
      设置此组件的放置模式。为了向后兼容，此属性的默认值为 DropMode.USE_SELECTION 。但是，建议使用其中一种其他模式，以改善用户体验。 DropMode.ON ，例如，提供了类似的行为，将项目显示为选中状态，但不会影响树中的实际选择。

      JTree 支持以下丢弃模式：

      • DropMode.USE_SELECTION
      • DropMode.ON
      • DropMode.INSERT
      • DropMode.ON_OR_INSERT

      仅当此组件具有接受丢弃的 TransferHandler 时，丢弃模式才有意义。

      参数：
      dropMode - 使用的丢弃模式
      抛出：
      IllegalArgumentException - 如果丢弃模式不受支持或 null
      自从：
      1.6
      参见：

    • getDropMode

      public final DropMode  getDropMode()
      返回此组件的放置模式。
      返回：
      该组件的放置模式
      自从：
      1.6
      参见：

    • getDropLocation

      @BeanProperty (bound =false) public final JTree.DropLocation  getDropLocation()
      返回此组件在组件上的 DnD 操作期间应直观指示为放置位置的位置，如果当前没有要显示的位置，则返回 null。

      此方法不适用于从 TransferHandler 查询放置位置，因为放置位置仅在 TransferHandler 的 canImport 返回并允许显示位置后设置。

      当此属性更改时，组件将触发名为“dropLocation”的属性更改事件。

      返回：
      下降位置
      自从：
      1.6
      参见：

    • isPathEditable

      public boolean isPathEditable(TreePath  path)
      返回 isEditable 。这是在编辑开始之前从 UI 调用的，以确保可以编辑给定的路径。这是作为子类添加过滤编辑而无需求助于创建新编辑器的入口点。
      参数：
      path - 一个 TreePath 标识一个节点
      返回：
      如果每个父节点和节点本身都是可编辑的，则为真
      参见：

    • getToolTipText

      public String  getToolTipText(MouseEvent  event)
      覆盖 JComponent 的 getToolTipText 方法，以便在设置了文本时允许使用渲染器的提示。

      注意：为了让 JTree 正确显示其渲染器的工具提示，JTree 必须是使用 ToolTipManager 注册的组件。这可以通过调用 ToolTipManager.sharedInstance().registerComponent(tree) 来完成。这不是自动完成的！

      重写：
      getToolTipText 在类 JComponent 中
      参数：
      event - 启动 ToolTip 显示的 MouseEvent
      返回：
      包含工具提示的字符串，如果 event 为 null，则为 null

    • convertValueToText

      public String  convertValueToText(Object  value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus)
      由呈现器调用以将指定值转换为文本。此实现返回 value.toString ，忽略所有其他参数。要控制转换，请子类化此方法并使用您需要的任何参数。
      参数：
      value - 要转换为文本的 Object
      selected - 如果节点被选中则为真
      expanded - 如果节点展开则为真
      leaf - 如果节点是叶节点则为真
      row - 指定节点显示行的整数，其中 0 是显示的第一行
      hasFocus - 如果节点有焦点则为真
      返回：
      节点值的 String 表示

    • getRowCount

      @BeanProperty (bound =false) public int getRowCount()
      返回可视节点数。如果一个节点的所有父节点都已展开，则该节点是可见的。仅当 isRootVisible() 为 true 时，根才包含在此计数中。如果尚未设置 UI，则返回 0。
      返回：
      可视节点数

    • setSelectionPath

      public void setSelectionPath(TreePath  path)
      选择由指定路径标识的节点。如果路径的任何组件被隐藏（在折叠的节点下），并且 getExpandsSelectedPaths 为真，它就会被暴露（可见）。
      参数：
      path - TreePath 指定要选择的节点

    • setSelectionPaths

      public void setSelectionPaths(TreePath [] paths)
      选择由指定路径数组标识的节点。如果任何路径中的任何组件被隐藏（在折叠的节点下），并且 getExpandsSelectedPaths 为真，它就会暴露（可见）。
      参数：
      paths - 指定要选择的节点的 TreePath 对象数组

    • setLeadSelectionPath

      @BeanProperty (description ="Lead selection path") public void setLeadSelectionPath(TreePath  newPath)
      设置标识为前导的路径。可能未选择潜在客户。 JTree 不维护线索，而是 UI 会更新它。

      这是绑定属性。

      参数：
      newPath - 新的引导路径
      自从：
      1.3

    • setAnchorSelectionPath

      @BeanProperty (description ="Anchor selection path") public void setAnchorSelectionPath(TreePath  newPath)
      设置标识为锚点的路径。锚点不是由 JTree 维护的，而是 UI 会更新它。

      这是绑定属性。

      参数：
      newPath - 新的锚点路径
      自从：
      1.3

    • setSelectionRow

      public void setSelectionRow(int row)
      选择显示中指定行的节点。
      参数：
      row - 要选择的行，其中 0 是显示的第一行

    • setSelectionRows

      public void setSelectionRows(int[] rows)
      选择与显示中每个指定行对应的节点。如果 rows 的特定元素 < 0 或 >= getRowCount ，它将被忽略。如果 rows 中的元素都不是有效行，则选择将被清除。也就是说，就像调用了 clearSelection 一样。
      参数：
      rows - 指定要选择的行的整数数组，其中 0 表示显示的第一行

    • addSelectionPath

      public void addSelectionPath(TreePath  path)
      将指定的 TreePath 标识的节点添加到当前选择。如果路径的任何组件不可见，并且 getExpandsSelectedPaths 为真，则它变为可见。

      请注意，JTree 不允许重复节点作为同一父节点下的子节点存在——每个兄弟节点必须是唯一对象。

      参数：
      path - 要添加的 TreePath

    • addSelectionPaths

      public void addSelectionPaths(TreePath [] paths)
      将路径数组中的每个路径添加到当前选择。如果任何路径的任何组件不可见且 getExpandsSelectedPaths 为真，则将其变为可见。

      请注意，JTree 不允许重复节点作为同一父节点下的子节点存在——每个兄弟节点必须是唯一对象。

      参数：
      paths - 指定要添加的节点的 TreePath 对象数组

    • addSelectionRow

      public void addSelectionRow(int row)
      将指定行的路径添加到当前选择。
      参数：
      row - 一个整数，指定要添加的节点的行，其中 0 是显示的第一行

    • addSelectionRows

      public void addSelectionRows(int[] rows)
      将每个指定行的路径添加到当前选择。
      参数：
      rows - 指定要添加的行的整数数组，其中 0 表示显示中的第一行

    • getLastSelectedPathComponent

      @BeanProperty (bound =false) public Object  getLastSelectedPathComponent()
      返回所选路径的最后一个路径组件。这是 getSelectionModel().getSelectionPath().getLastPathComponent() 的便捷方法。这通常仅在选择具有一条路径时才有用。
      返回：
      所选路径的最后一个路径组件，如果未选择任何内容，则为 null
      参见：

    • getLeadSelectionPath

      public TreePath  getLeadSelectionPath()
      返回标识为前导的路径。
      返回：
      确定为主要路径

    • getAnchorSelectionPath

      public TreePath  getAnchorSelectionPath()
      返回标识为锚点的路径。
      返回：
      标识为锚点的路径
      自从：
      1.3

    • getSelectionPath

      public TreePath  getSelectionPath()
      返回第一个选定节点的路径。
      返回：
      第一个选定节点的 TreePath，如果当前未选择任何节点，则为 null

    • getSelectionPaths

      public TreePath [] getSelectionPaths()
      返回所有选定值的路径。
      返回：
      指示所选节点的 TreePath 对象数组，如果当前未选择任何内容，则为 null

    • getSelectionRows

      public int[] getSelectionRows()
      返回所有当前选定的行。此方法只是转发给 TreeSelectionModel 。如果未选择任何内容，null 或将返回一个空数组，基于 TreeSelectionModel 实现。
      返回：
      标识所有当前选定行的整数数组，其中 0 是显示中的第一行

    • getSelectionCount

      @BeanProperty (bound =false) public int getSelectionCount()
      返回选择的节点数。
      返回：
      选择的节点数

    • getMinSelectionRow

      @BeanProperty (bound =false) public int getMinSelectionRow()
      返回最小的选定行。如果选择为空，或者所选路径均不可见，则返回 -1。
      返回：
      最小的选定行

    • getMaxSelectionRow

      @BeanProperty (bound =false) public int getMaxSelectionRow()
      返回最大的选定行。如果选择为空，或者所选路径均不可见，则返回 -1。
      返回：
      最大的选定行

    • getLeadSelectionRow

      @BeanProperty (bound =false) public int getLeadSelectionRow()
      返回对应于前导路径的行索引。
      返回：
      一个整数，给出引导路径的行索引，其中 0 是显示中的第一行；或 -1 如果 leadPath 是 null

    • isPathSelected

      public boolean isPathSelected(TreePath  path)
      如果当前选择了由路径标识的项目，则返回 true。
      参数：
      path - 一个 TreePath 标识一个节点
      返回：
      如果节点被选中则为真

    • isRowSelected

      public boolean isRowSelected(int row)
      如果选择了由 row 标识的节点，则返回 true。
      参数：
      row - 指定显示行的整数，其中 0 是显示中的第一行
      返回：
      如果节点被选中则为真

    • getExpandedDescendants

      public Enumeration <TreePath > getExpandedDescendants(TreePath  parent)
      返回当前展开的路径 parent 的后代的 Enumeration。如果 parent 当前未展开，这将返回 null 。如果在遍历返回的 Enumeration 时展开/折叠节点，这可能不会返回所有展开的路径，或者可能返回不再展开的路径。
      参数：
      parent - 要检查的路径
      返回：
      parent 的后代的 Enumeration，如果 parent 当前未扩展，则为 null

    • hasBeenExpanded

      public boolean hasBeenExpanded(TreePath  path)
      如果路径标识的节点曾经展开过，则返回 true。
      参数：
      path - 一个 TreePath 标识一个节点
      返回：
      如果 path 曾经被扩展过，则为真

    • isExpanded

      public boolean isExpanded(TreePath  path)
      如果路径标识的节点当前已展开，则返回 true，
      参数：
      path - TreePath 指定要检查的节点
      返回：
      如果折叠节点路径中的任何节点，则为 false；如果展开路径中的所有节点，则为 true

    • isExpanded

      public boolean isExpanded(int row)
      如果指定显示行的节点当前已展开，则返回 true。
      参数：
      row - 要检查的行，其中 0 是显示的第一行
      返回：
      如果节点当前已展开，则为 true，否则为 false

    • isCollapsed

      public boolean isCollapsed(TreePath  path)
      如果 path 标识的值当前已折叠，则返回 true，如果当前未显示 path 中的任何值，则返回 false。
      参数：
      path - 要检查的 TreePath
      返回：
      如果折叠节点路径中的任何节点，则为 true；如果展开路径中的所有节点，则为 false

    • isCollapsed

      public boolean isCollapsed(int row)
      如果指定显示行的节点折叠，则返回 true。
      参数：
      row - 要检查的行，其中 0 是显示的第一行
      返回：
      如果节点当前折叠，则为 true，否则为 false

    • makeVisible

      public void makeVisible(TreePath  path)
      确保路径标识的节点当前可见。
      参数：
      path - TreePath 可见

    • isVisible

      public boolean isVisible(TreePath  path)
      如果路径标识的值当前可见，则返回 true，这意味着它要么是根，要么它的所有父项都已展开。否则，此方法返回 false。
      参数：
      path - TreePath 识别节点
      返回：
      如果节点可见，则为 true，否则为 false

    • getPathBounds

      public Rectangle  getPathBounds(TreePath  path)
      返回指定节点将被绘制到的Rectangle。如果路径中的任何组件被隐藏（在折叠的父项下），则返回 null。

      笔记：
      此方法返回一个有效的矩形，即使当前未显示指定的节点。

      参数：
      path - TreePath 标识节点
      返回：
      Rectangle 节点被绘制，或 null

    • getRowBounds

      public Rectangle  getRowBounds(int row)
      返回绘制指定行节点的Rectangle。
      参数：
      row - 要绘制的行，其中 0 是显示的第一行
      返回：
      Rectangle 节点被绘制在

    • scrollPathToVisible

      public void scrollPathToVisible(TreePath  path)
      确保路径中的所有路径组件都展开（最后一个路径组件除外）并滚动，以便显示路径标识的节点。仅当此 JTree 包含在 JScrollPane 中时才有效。
      参数：
      path - TreePath 标识要进入视图的节点

    • scrollRowToVisible

      public void scrollRowToVisible(int row)
      滚动由行标识的项目，直到它显示出来。执行将行显示在视图中所需的最小滚动量。仅当此 JTree 包含在 JScrollPane 中时才有效。
      参数：
      row - 一个整数，指定要滚动的行，其中 0 是显示的第一行

    • getPathForRow

      @BeanProperty (bound =false) public TreePath  getPathForRow(int row)
      返回指定行的路径。如果 row 不可见，或者没有设置 TreeUI，则返回 null。
      参数：
      row - 指定行的整数
      返回：
      TreePath到指定节点，null如果row < 0或row >= getRowCount()

    • getRowForPath

      public int getRowForPath(TreePath  path)
      返回显示由指定路径标识的节点的行。
      参数：
      path - TreePath 标识一个节点
      返回：
      指定显示行的整数，其中 0 是显示中的第一行，如果路径中的任何元素隐藏在折叠的父项下，则为 -1。

    • expandPath

      public void expandPath(TreePath  path)
      确保由指定路径标识的节点已展开且可见。如果路径中的最后一项是叶子，则这将无效。
      参数：
      path - TreePath 标识一个节点

    • expandRow

      public void expandRow(int row)
      确保指定行中的节点已展开且可见。

      如果 row < 0 或 >= getRowCount 这将无效。

      参数：
      row - 指定显示行的整数，其中 0 是显示中的第一行

    • collapsePath

      public void collapsePath(TreePath  path)
      确保由指定路径标识的节点已折叠且可见。
      参数：
      path - TreePath 标识一个节点

    • collapseRow

      public void collapseRow(int row)
      确保折叠指定行中的节点。

      如果 row < 0 或 >= getRowCount 这将无效。

      参数：
      row - 指定显示行的整数，其中 0 是显示中的第一行

    • getPathForLocation

      public TreePath  getPathForLocation(int x, int y)
      返回指定位置的节点的路径。
      参数：
      x - 一个整数，表示从显示区域的左边缘开始水平方向的像素数，减去任何左边距
      y - 一个整数，表示从显示区域顶部开始的垂直像素数，减去任何上边距
      返回：
      该位置节点的 TreePath

    • getRowForLocation

      public int getRowForLocation(int x, int y)
      返回指定位置的行。
      参数：
      x - 一个整数，表示从显示区域的左边缘开始水平方向的像素数，减去任何左边距
      y - 一个整数，表示从显示区域顶部开始的垂直像素数，减去任何上边距
      返回：
      与位置对应的行，如果位置不在显示单元格的边界内，则为 -1
      参见：

    • getClosestPathForLocation

      public TreePath  getClosestPathForLocation(int x, int y)
      返回最接近 x,y 的节点的路径。如果当前没有节点可见，或者没有模型，则返回 null ，否则它始终返回有效路径。要测试节点是否恰好位于 x、y，请获取节点的边界并针对该节点测试 x、y。
      参数：
      x - 一个整数，表示从显示区域的左边缘开始水平方向的像素数，减去任何左边距
      y - 一个整数，表示从显示区域顶部开始的垂直像素数，减去任何上边距
      返回：
      TreePath 表示最接近该位置的节点，null 如果没有任何内容可见或没有模型
      参见：

    • getClosestRowForLocation

      public int getClosestRowForLocation(int x, int y)
      将行返回到最接近 x,y 的节点。如果没有节点可见或没有模型，则返回 -1。否则，它总是返回一个有效行。要测试返回的对象是否恰好位于 x, y，请获取返回行处节点的边界并针对它测试 x, y。
      参数：
      x - 一个整数，表示从显示区域的左边缘开始水平方向的像素数，减去任何左边距
      y - 一个整数，表示从显示区域顶部开始的垂直像素数，减去任何上边距
      返回：
      最靠近该位置的行，如果没有任何内容可见或没有模型，则为 -1
      参见：

    • isEditing

      @BeanProperty (bound =false) public boolean isEditing()
      如果正在编辑树，则返回 true。可以使用 getSelectionPath 获得正在编辑的项目。
      返回：
      如果用户当前正在编辑节点，则为真
      参见：

    • stopEditing

      public boolean stopEditing()
      结束当前编辑会话。 （DefaultTreeCellEditor 对象保存单元格上当前正在进行的任何编辑。其他实现可能会有不同的操作。）如果树没有被编辑则没有效果。
      笔记：
      要在用户更改其在树中的位置时自动进行编辑保存，请使用 setInvokesStopCellEditing(boolean) 。
      返回：
      如果编辑正在进行并且现在停止，则为 true；如果编辑未在进行，则为 false

    • cancelEditing

      public void cancelEditing()
      取消当前的编辑会话。如果树没有被编辑则没有效果。

    • startEditingAtPath

      public void startEditingAtPath(TreePath  path)
      选择由指定路径标识的节点并开始编辑。如果 CellEditor 不允许编辑指定项目，则编辑尝试失败。
      参数：
      path - TreePath 标识一个节点

    • getEditingPath

      @BeanProperty (bound =false) public TreePath  getEditingPath()
      返回当前正在编辑的元素的路径。
      返回：
      正在编辑的节点的 TreePath

    • setSelectionModel

      @BeanProperty (description ="The tree\'s selection model.") public void setSelectionModel(TreeSelectionModel  selectionModel)
      设置树的选择模型。当指定 null 值时，使用空的 selectionModel，不允许选择。

      这是绑定属性。

      参数：
      selectionModel - 要使用的 TreeSelectionModel，或禁用选择的 null
      参见：

    • getSelectionModel

      public TreeSelectionModel  getSelectionModel()
      返回选择的模型。这应该总是返回一个非 null 值。如果您不想选择任何内容，请将选择模型设置为 null ，这会强制使用空选择模型。
      返回：
      选择模型
      参见：

    • getPathBetweenRows

      protected TreePath [] getPathBetweenRows(int index0, int index1)
      返回指定行之间的路径（包括）。如果指定的索引在可查看的行集合内，或绑定了可查看的行集合，则索引受可查看的行集合约束。如果指定的索引不在可查看的行集中，或者未绑定可查看的行集，则返回一个空数组。例如，如果行计数为 10 ，并且使用 -1, 20 调用此方法，则指定的索引被限制为可查看的行集，并且这被视为使用 0, 9 调用。另一方面，如果这是用 -10, -1 调用的，则指定的索引不会绑定可查看的行集，并返回一个空数组。

      参数不依赖于顺序。也就是说， getPathBetweenRows(x, y) 等同于 getPathBetweenRows(y, x)。

      如果行数为 0 或指定的索引未绑定可查看的行集，则返回一个空数组。

      参数：
      index0 - 范围内的第一个索引
      index1 - 范围内的最后一个索引
      返回：
      指定行索引之间的路径（包括）

    • setSelectionInterval

      public void setSelectionInterval(int index0, int index1)
      选择指定间隔（含）内的行。如果指定索引在可查看行集中，或绑定可查看行集，则指定行受可查看行集约束。如果指定的索引不在可查看的行集中，或者未绑定可查看的行集，则清除选择。例如，如果行数为 10 ，并且使用 -1, 20 调用此方法，则指定的索引会限制可见范围，并且将其视为使用 0, 9 调用。另一方面，如果这是用 -10, -1 调用的，则指定的索引不会绑定可查看的行集，并且选择被清除。

      参数不依赖于顺序。也就是说， setSelectionInterval(x, y) 等同于 setSelectionInterval(y, x)。

      参数：
      index0 - 要选择的范围中的第一个索引
      index1 - 选择范围内的最后一个索引

    • addSelectionInterval

      public void addSelectionInterval(int index0, int index1)
      将指定的行（包括）添加到选择中。如果指定的索引在可查看的行集合内，或绑定了可查看的行集合，则指定的索引受可查看的行集合约束。如果索引不在可查看的行集中，或者未绑定可查看的行集，则选择不变。例如，如果行数为 10 ，并且使用 -1, 20 调用此方法，则指定的索引会限制可视范围，并且将其视为使用 0, 9 调用。另一方面，如果这是用 -10, -1 调用的，则指定的索引不会绑定可查看的行集，并且选择不变。

      参数不依赖于顺序。也就是说， addSelectionInterval(x, y) 等同于 addSelectionInterval(y, x)。

      参数：
      index0 - 范围内要添加到选择的第一个索引
      index1 - 要添加到选择的范围中的最后一个索引

    • removeSelectionInterval

      public void removeSelectionInterval(int index0, int index1)
      从选择中删除指定的行（包括）。如果指定的索引在可查看的行集合内，或绑定了可查看的行集合，则指定的索引受可查看的行集合约束。如果指定的索引不在可查看的行集中，或者未绑定可查看的行集，则选择不变。例如，如果行数为 10 ，并且使用 -1, 20 调用此方法，则指定的范围将限制可视范围，并且这被视为使用 0, 9 调用。另一方面，如果这是用 -10, -1 调用的，则指定的范围不会绑定可查看的行集，并且选择不变。

      参数不依赖于顺序。也就是说， removeSelectionInterval(x, y) 等同于 removeSelectionInterval(y, x)。

      参数：
      index0 - 从选择中删除的第一行
      index1 - 从选择中删除的最后一行

    • removeSelectionPath

      public void removeSelectionPath(TreePath  path)
      从当前选择中删除由指定路径标识的节点。
      参数：
      path - TreePath 标识一个节点

    • removeSelectionPaths

      public void removeSelectionPaths(TreePath [] paths)
      从当前选择中删除由指定路径标识的节点。
      参数：
      paths - 指定要删除的节点的 TreePath 对象数组

    • removeSelectionRow

      public void removeSelectionRow(int row)
      从当前选择中删除索引 row 处的行。
      参数：
      row - 要删除的行

    • removeSelectionRows

      public void removeSelectionRows(int[] rows)
      删除在每个指定行处选择的行。
      参数：
      rows - 指定显示行的整数数组，其中 0 是显示中的第一行

    • clearSelection

      public void clearSelection()
      清除选择。

    • isSelectionEmpty

      @BeanProperty (bound =false) public boolean isSelectionEmpty()
      如果选择当前为空，则返回 true。
      返回：
      如果选择当前为空，则为真

    • addTreeExpansionListener

      public void addTreeExpansionListener(TreeExpansionListener  tel)
      为 TreeExpansion 事件添加一个监听器。
      参数：
      tel - 一个 TreeExpansionListener，当树节点展开或折叠时会收到通知（“负展开”）

    • removeTreeExpansionListener

      public void removeTreeExpansionListener(TreeExpansionListener  tel)
      删除 TreeExpansion 事件的监听器。
      参数：
      tel - 要删除的 TreeExpansionListener

    • getTreeExpansionListeners

      @BeanProperty (bound =false) public TreeExpansionListener [] getTreeExpansionListeners()
      返回使用 addTreeExpansionListener() 添加到此 JTree 的所有 TreeExpansionListener 的数组。
      返回：
      添加所有 TreeExpansionListener s，如果没有添加任何监听器，则为空数组
      自从：
      1.4

    • addTreeWillExpandListener

      public void addTreeWillExpandListener(TreeWillExpandListener  tel)
      为 TreeWillExpand 事件添加一个监听器。
      参数：
      tel - 一个 TreeWillExpandListener 将在展开或折叠树节点时收到通知（“负展开”）

    • removeTreeWillExpandListener

      public void removeTreeWillExpandListener(TreeWillExpandListener  tel)
      删除 TreeWillExpand 事件的监听器。
      参数：
      tel - 要删除的 TreeWillExpandListener

    • getTreeWillExpandListeners

      @BeanProperty (bound =false) public TreeWillExpandListener [] getTreeWillExpandListeners()
      返回使用 addTreeWillExpandListener() 添加到此 JTree 的所有 TreeWillExpandListener 的数组。
      返回：
      添加所有 TreeWillExpandListener s，如果没有添加任何监听器，则为空数组
      自从：
      1.4

    • fireTreeExpanded

      public void fireTreeExpanded(TreePath  path)
      通知所有已注册对此事件类型的通知感兴趣的监听器。事件实例是使用 path 参数延迟创建的。
      参数：
      path - TreePath 表示展开的节点
      参见：

    • fireTreeCollapsed

      public void fireTreeCollapsed(TreePath  path)
      通知所有已注册对此事件类型的通知感兴趣的监听器。事件实例是使用 path 参数延迟创建的。
      参数：
      path - TreePath 表示折叠的节点
      参见：

    • fireTreeWillExpand

      public void fireTreeWillExpand(TreePath  path) throws ExpandVetoException
      通知所有已注册对此事件类型的通知感兴趣的监听器。事件实例是使用 path 参数延迟创建的。
      参数：
      path - TreePath 表示展开的节点
      抛出：
      ExpandVetoException - 如果阻止发生扩展
      参见：

    • fireTreeWillCollapse

      public void fireTreeWillCollapse(TreePath  path) throws ExpandVetoException
      通知所有已注册对此事件类型的通知感兴趣的监听器。事件实例是使用 path 参数延迟创建的。
      参数：
      path - TreePath 表示展开的节点
      抛出：
      ExpandVetoException - 如果防止崩溃发生
      参见：

    • addTreeSelectionListener

      public void addTreeSelectionListener(TreeSelectionListener  tsl)
      为 TreeSelection 事件添加一个监听器。
      参数：
      tsl - 当选择或取消选择节点时将通知的 TreeSelectionListener（“否定选择”）

    • removeTreeSelectionListener

      public void removeTreeSelectionListener(TreeSelectionListener  tsl)
      删除 TreeSelection 监听器。
      参数：
      tsl - 要删除的 TreeSelectionListener

    • getTreeSelectionListeners

      @BeanProperty (bound =false) public TreeSelectionListener [] getTreeSelectionListeners()
      返回使用 addTreeSelectionListener() 添加到此 JTree 的所有 TreeSelectionListener 的数组。
      返回：
      添加所有 TreeSelectionListener s，如果没有添加任何监听器，则为空数组
      自从：
      1.4

    • fireValueChanged

      protected void fireValueChanged(TreeSelectionEvent  e)
      通知所有已注册对此事件类型的通知感兴趣的监听。
      参数：
      e - 要解雇的 TreeSelectionEvent；选择或取消选择节点时由TreeSelectionModel生成
      参见：

    • treeDidChange

      public void treeDidChange()
      当树的变化足以让我们需要调整边界大小，但还不足以让我们需要移除扩展的节点集时发送（例如，节点被扩展或折叠，或者节点被插入到树中）。您永远不必调用它，UI 将在需要时调用它。

    • setVisibleRowCount

      @BeanProperty (description ="The number of rows that are to be displayed.") public void setVisibleRowCount(int newCount)
      设置要显示的行数。这仅在树包含在 JScrollPane 中时才有效，并将调整该滚动窗格的首选大小和大小。

      这是绑定属性。

      参数：
      newCount - 要显示的行数

    • getVisibleRowCount

      public int getVisibleRowCount()
      返回显示区域中显示的行数。
      返回：
      显示的行数

    • getNextMatch

      public TreePath  getNextMatch(String  prefix, int startingRow, Position.Bias  bias)
      将 TreePath 返回到以前缀开头的下一个树元素。为了处理 TreePath 到 String 的转换，使用了 convertValueToText。
      参数：
      prefix - 用于测试匹配的字符串
      startingRow - 开始搜索的行
      bias - 搜索方向，Position.Bias.Forward 或 Position.Bias.Backward。
      返回：
      以前缀开头的下一个树元素的 TreePath；否则为空
      抛出：
      IllegalArgumentException - 如果 prefix 为 null 或 startingRow 超出范围
      自从：
      1.4

    • getPreferredScrollableViewportSize

      @BeanProperty (bound =false) public Dimension  getPreferredScrollableViewportSize()
      返回 JTree 的首选显示大小。高度由 getVisibleRowCount 确定，宽度为当前首选宽度。
      指定者：
      getPreferredScrollableViewportSize 在接口 Scrollable 中
      返回：
      包含首选大小的 Dimension 对象
      参见：

    • getScrollableUnitIncrement

      public int getScrollableUnitIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回滚动时增加的量。该数量是未完全显示的第一个显示行的高度，或者如果完全显示，则为滚动方向下一行的高度。
      指定者：
      getScrollableUnitIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL
      direction - 小于零向上/向左滚动，大于零向下/向右滚动
      返回：
      在指定方向滚动的“单位”增量
      参见：

    • getScrollableBlockIncrement

      public int getScrollableBlockIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回块增量的数量，即 visibleRect 的高度或宽度，基于 orientation 。
      指定者：
      getScrollableBlockIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL
      direction - 小于零向上/向左滚动，大于零向下/向右滚动。
      返回：
      在指定方向滚动的“块”增量
      参见：

    • getScrollableTracksViewportWidth

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportWidth()
      返回 false 表示视口的宽度不决定表格的宽度，除非树的首选宽度小于视口宽度。换句话说：确保树永远不会小于它的视口。
      指定者：
      getScrollableTracksViewportWidth 在接口 Scrollable 中
      返回：
      树是否应该跟踪视口的宽度
      参见：

    • getScrollableTracksViewportHeight

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportHeight()
      返回 false 表示视口的高度不决定表格的高度，除非树的首选高度小于视口高度。换句话说：确保树永远不会小于它的视口。
      指定者：
      getScrollableTracksViewportHeight 在接口 Scrollable 中
      返回：
      树是否应该跟踪视口的高度
      参见：

    • setExpandedState

      protected void setExpandedState(TreePath  path, boolean state)
      设置此 JTree 的展开状态。如果 state 为真，则 path 和路径的所有父级都标记为展开。如果 state 为 false，则 path 的所有父级都标记为 EXPANDED，但 path 本身标记为 collapsed。

      如果 TreeWillExpandListener 否决它，这将失败。

      参数：
      path - 一个 TreePath 标识一个节点
      state - 如果是 true ，则 path 和路径的所有父级都标记为展开。否则，path 的所有父级都标记为 EXPANDED，但 path 本身标记为已折叠。

    • getDescendantToggledPaths

      protected Enumeration <TreePath > getDescendantToggledPaths(TreePath  parent)
      返回 TreePaths 的 Enumeration 已扩展为 parent 的后代。
      参数：
      parent - 路径
      返回：
      TreePaths 的 Enumeration

    • removeDescendantToggledPaths

      protected void removeDescendantToggledPaths(Enumeration <TreePath > toRemove)
      删除 toRemove 中 TreePaths 的任何已扩展的后代。
      参数：
      toRemove - 要删除的路径的枚举； null 的值被忽略
      抛出：
      ClassCastException - 如果 toRemove 包含一个不是 TreePath 的元素； null 值被忽略

    • clearToggledPaths

      protected void clearToggledPaths()
      清除切换树路径的缓存。这不会发出任何 TreeExpansionListener 事件。

    • createTreeModelListener

      protected TreeModelListener  createTreeModelListener()
      创建并返回 TreeModelHandler 的实例。返回的对象负责在 TreeModel 变化时更新展开状态。

      有关扩展状态含义的更多信息，请参阅上面的 JTree description 。

      返回：
      TreeModelHandler 的实例

    • removeDescendantSelectedPaths

      protected boolean removeDescendantSelectedPaths(TreePath  path, boolean includePath)
      删除选择中作为 path 后代的所有路径。如果 includePath 为真并且选择了 path，它将从选择中移除。
      参数：
      path - 路径
      includePath - 是 true 和 path 被选中，它将从选择中删除。
      返回：
      如果选择了后代，则为真
      自从：
      1.3

    • paramString

      protected String  paramString()
      返回此 JTree 的字符串表示形式。此方法仅用于调试目的，返回字符串的内容和格式可能因实现而异。返回的字符串可能为空，但可能不是 null 。
      重写：
      paramString 在类 JComponent 中
      返回：
      这个 JTree 的字符串表示。

    • getAccessibleContext

      @BeanProperty (bound =false) public AccessibleContext  getAccessibleContext()
      获取与此 JTree 关联的 AccessibleContext。对于 JTrees，AccessibleContext 采用 AccessibleJTree 的形式。如有必要，将创建一个新的 AccessibleJTree 实例。
      指定者：
      getAccessibleContext 在接口 Accessible 中
      重写：
      getAccessibleContext 在类 Component 中
      返回：
      作为此 JTree 的 AccessibleContext 的 AccessibleJTree