如何为一组DefaultMutableTreeNode节点查找共同父节点？

我来帮你搞定这个Swing树节点的问题！首先得说，Swing本身并没有直接提供开箱即用的方法来查找一组DefaultMutableTreeNode的共同父节点，但我们可以利用它自带的API来实现一个简洁、高效的解决方案，完全符合Java 8的风格，而且维护成本很低。

核心思路：利用路径找最长公共前缀 #

每个DefaultMutableTreeNode都有getPath()方法，能返回从根节点到当前节点的完整路径数组。我们的目标就是找到所有节点路径的最长公共前缀，这个前缀的最后一个节点就是最深的共同父节点。

完整实现代码 #

先看能通过你测试用例的实现：

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeNode;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class TreeHelper {

    public static Optional<DefaultMutableTreeNode> findCommonParent(List<DefaultMutableTreeNode> nodes) {
        // 处理边界情况：空列表、包含null节点直接返回空
        if (nodes == null || nodes.isEmpty() || nodes.contains(null)) {
            return Optional.empty();
        }

        // 获取所有节点的完整路径（从根到自身）
        List<TreeNode[]> nodePaths = nodes.stream()
                .map(DefaultMutableTreeNode::getPath)
                .collect(Collectors.toList());

        // 检查所有节点是否属于同一棵树（根节点必须相同）
        TreeNode firstRoot = nodePaths.get(0)[0];
        boolean sameTree = nodePaths.stream().allMatch(path -> path[0].equals(firstRoot));
        if (!sameTree) {
            return Optional.empty();
        }

        // 找到最短路径的长度，避免后续数组越界
        int shortestPathLength = nodePaths.stream()
                .mapToInt(TreeNode[]::length)
                .min()
                .orElse(0);

        // 从根节点开始，逐层找最长公共前缀
        DefaultMutableTreeNode commonParent = (DefaultMutableTreeNode) firstRoot;
        for (int i = 1; i < shortestPathLength; i++) {
            TreeNode currentCandidate = nodePaths.get(0)[i];
            // 确认所有节点的当前路径位置都一致
            boolean allMatch = nodePaths.stream().allMatch(path -> path[i].equals(currentCandidate));
            if (allMatch) {
                commonParent = (DefaultMutableTreeNode) currentCandidate;
            } else {
                // 出现不匹配，停止遍历
                break;
            }
        }

        return Optional.of(commonParent);
    }
}

代码说明 #

1. 边界处理：先过滤掉空列表、包含null的情况，避免后续报错。
2. 路径收集：用getPath()获取每个节点的完整路径，这是Swing内置方法，效率有保障。
3. 同树检查：如果节点不在同一棵树，肯定没有共同父节点，直接返回空。
4. 最短路径限制：防止遍历到某个节点路径不存在的位置，比如一个节点是叶子，另一个是深层节点。
5. 逐层匹配：从根往下逐个节点对比，找到第一个不匹配的位置，前一个节点就是最深的共同父。

测试验证 #

你的测试用例完全能通过：

• 对于nodeF和nodeJ，它们的路径分别是[a,e,f]和[a,e,g,j]，最短路径长度是3。对比到第2个位置（索引1）是e，第3个位置（索引2）f和g不匹配，所以共同父是e，符合预期。
• 当传入一个不属于当前树的新节点时，同树检查失败，返回空Optional，也符合预期。

可选优化：极致性能版（替换Stream为循环） #

如果你的树节点数量极大，担心Stream的开销，可以把Stream换成普通循环，性能会略高一点，逻辑完全一致：

public static Optional<DefaultMutableTreeNode> findCommonParent(List<DefaultMutableTreeNode> nodes) {
    if (nodes == null || nodes.isEmpty() || nodes.contains(null)) {
        return Optional.empty();
    }

    TreeNode[] firstPath = nodes.get(0).getPath();
    // 检查同树
    for (DefaultMutableTreeNode node : nodes) {
        TreeNode[] path = node.getPath();
        if (!path[0].equals(firstPath[0])) {
            return Optional.empty();
        }
    }

    // 找最短路径长度
    int shortestLength = firstPath.length;
    for (DefaultMutableTreeNode node : nodes) {
        int len = node.getPath().length;
        if (len < shortestLength) {
            shortestLength = len;
        }
    }

    DefaultMutableTreeNode commonParent = (DefaultMutableTreeNode) firstPath[0];
    for (int i = 1; i < shortestLength; i++) {
        TreeNode candidate = firstPath[i];
        boolean match = true;
        for (DefaultMutableTreeNode node : nodes) {
            if (!node.getPath()[i].equals(candidate)) {
                match = false;
                break;
            }
        }
        if (match) {
            commonParent = (DefaultMutableTreeNode) candidate;
        } else {
            break;
        }
    }

    return Optional.of(commonParent);
}

这个实现没有用任何外部库，完全依赖Swing的原生API，代码简洁可读，维护成本低，性能也足够应付大多数场景。

内容来源于stack exchange