更新JTree节点时如何保留选中与展开状态？（IntelliJ插件开发）

问题根源在于每次更新时全量创建新的TreeNode实例，原有节点与新节点是不同对象，JTree无法关联状态，导致展开和选中信息丢失。解决方案核心是复用匹配的节点，仅更新数据差异，再手动保存/恢复状态。

步骤1：修改VariableInfoTreeNode，支持节点匹配与数据更新 #

将节点改为可更新数据，并添加匹配逻辑（用于识别同一变量）：

class VariableInfoTreeNode(
    private var variableInfo: VariableInfo, // 改为var以支持更新
    private val myParentNode: TreeNode?,
) : TreeNode {
    // 判断当前节点是否与给定VariableInfo对应同一变量（可根据业务调整匹配规则，比如name+type）
    fun matches(info: VariableInfo): Boolean {
        return this.variableInfo.name == info.name
    }

    // 更新当前节点数据，并递归更新子节点
    fun update(info: VariableInfo) {
        this.variableInfo = info
        val existingChildren = _children.toMutableList()
        val newChildInfos = info.children ?: emptyList()

        // 更新现有子节点或新增子节点
        newChildInfos.forEach { newChildInfo ->
            existingChildren.firstOrNull { it.matches(newChildInfo) }?.let { existingNode ->
                existingNode.update(newChildInfo)
            } ?: run {
                existingChildren.add(VariableInfoTreeNode(newChildInfo, this))
            }
        }

        // 删除已不存在的子节点
        existingChildren.removeAll { existingNode ->
            newChildInfos.none { it.name == existingNode.variableInfo.name }
        }

        _children = existingChildren
    }

    // 将原来的lazy子节点改为可变列表，初始化时加载
    private var _children: List<VariableInfoTreeNode> = emptyList()

    init {
        _children = variableInfo.children?.map { VariableInfoTreeNode(it, this) } ?: emptyList()
    }

    // 原有方法保持不变
    override fun toString(): String {
        return "${variableInfo.name}:${variableInfo.type} ${variableInfo.value}"
    }

    override fun getChildAt(childIndex: Int): TreeNode = _children[childIndex]
    override fun getChildCount(): Int = _children.size
    override fun getParent(): TreeNode? = myParentNode
    override fun getIndex(node: TreeNode?): Int {
        return _children.indexOfFirst { it == node }
    }
    override fun getAllowsChildren(): Boolean = true
    override fun isLeaf(): Boolean = false
    override fun children(): Enumeration<out TreeNode> = Collections.enumeration(_children)
}

步骤2：修改VariableInfoRootNode，实现增量更新 #

不再全量创建新节点，而是复用原有匹配节点，仅处理新增/删除/更新：

class VariableInfoRootNode: TreeNode {
    private var children = emptyList<VariableInfo>()
    private var childrenNodes = emptyList<VariableInfoTreeNode>()

    init {
        refreshChildTree()
    }

    fun setVariableInfo(variableInfoList: List<VariableInfo>) {
        val existingNodes = childrenNodes.toMutableList()
        val newInfos = variableInfoList

        // 更新现有节点或新增根节点
        newInfos.forEach { newInfo ->
            existingNodes.firstOrNull { it.matches(newInfo) }?.let { existingNode ->
                existingNode.update(newInfo)
            } ?: run {
                existingNodes.add(VariableInfoTreeNode(newInfo, this))
            }
        }

        // 删除已不存在的根节点
        existingNodes.removeAll { existingNode ->
            newInfos.none { it.name == existingNode.variableInfo.name }
        }

        children = newInfos
        childrenNodes = existingNodes
    }

    private fun refreshChildTree() {
        childrenNodes = children.map { VariableInfoTreeNode(it, this) }
    }

    // 原有方法保持不变
    override fun getChildAt(childIndex: Int): TreeNode = childrenNodes[childIndex]
    override fun getChildCount(): Int = childrenNodes.size
    override fun getParent(): TreeNode? = null
    override fun getIndex(node: TreeNode?): Int = childrenNodes.indexOfFirst { it == node }
    override fun getAllowsChildren(): Boolean = true
    override fun isLeaf(): Boolean = false
    override fun children(): Enumeration<out TreeNode> = Collections.enumeration(childrenNodes)
}

步骤3：修改DebugBoardView，保存并恢复树状态 #

在更新前后分别保存展开路径和选中路径，更新完成后恢复：

class DebugBoardView : JPanel(GridLayout()) {
    private val rootNode = VariableInfoRootNode()
    private val treeModel = DefaultTreeModel(rootNode)
    private val tree: Tree = Tree(treeModel).apply {
        isRootVisible = false
    }

    fun onVariablesUpdate(list: List<VariableInfo>) {
        // 1. 保存当前所有展开路径
        val expandedPaths = mutableListOf<TreePath>()
        tree.expandedDescendants?.forEach { expandedPaths.add(it) }

        // 2. 保存当前选中路径
        val selectedPaths = tree.selectionPaths?.toList() ?: emptyList()

        // 3. 增量更新节点数据
        rootNode.setVariableInfo(list)
        treeModel.nodeStructureChanged(rootNode)

        // 4. 恢复展开状态
        expandedPaths.forEach { tree.expandPath(it) }

        // 5. 恢复选中状态
        if (selectedPaths.isNotEmpty()) {
            tree.selectionPaths = selectedPaths.toTypedArray()
        }
    }

    init {
        add(tree)
        javax.swing.Timer(5000) {
            onVariablesUpdate(fakeInfo)
        }.start()
    }
}

关键说明 #

• 节点匹配规则：示例中使用name作为唯一标识，若业务中有同名但不同类型的变量，可修改matches方法为name + type组合匹配。
• 状态恢复：因为复用了原有节点对象，保存的TreePath依然有效，能准确恢复展开和选中状态。
• 性能优化：增量更新避免了全量节点重建，同时减少了Tree的重绘开销，适合频繁更新的场景。

内容的提问来源于stack exchange，提问作者AmirHossein Abdolmotallebi