本文讲解如何在 java 组合模式（composite pattern）中，通过递归深度控制前缀长度，使 `display()` 方法正确输出逐级缩进的树形结构，避免前缀指数级叠加问题。
在使用组合模式构建文件系统（如 Directory 与 File）时，一个常见且关键的需求是：以清晰的树形结构打印整个组件层次。理想效果是每深入一层子目录或子文件，缩进前缀（如 +）增加一个字符，而非呈指数增长（如 + → ++ → ++++）。你当前遇到的问题——prefix + prefix 导致前缀翻倍——本质是将“字符串拼接逻辑”错误地嵌入了递归调用路径，而非基于层级深度动态生成。
✅ 正确解法：用深度参数替代前缀字符串传递
核心思路是：不传递 String prefix，而是传递 int depth。每个节点根据自身所处的层级（从 1 开始计数），按需生成对应数量的 + 字符作为当前行前缀。这既符合组合模式的递归本质，又完全解耦了前缀构造逻辑。
修改 Component 接口（推荐升级）
为保持接口一致性与类型安全，建议将 display(String prefix) 替换为 display(int depth)：
public interface Component {
String getName();
int getSize();
int getCount();
String display(int depth); // ← 关键变更：接收整数深度
Component search(String name);
}更新 File 类（Leaf 实现）
File 不含子节点，只需生成本行内容，无需递归；前缀由调用方（父 Directory）传入深度后统一构造：
public class File implements Component {
private final String name;
private final int size;
public File(String name, int size) {
this.name = name;
this.size = size;
}
@Override
public String getName() { return name; }
@Override
public int getSize() { return size; }
@Override
public int getCount() { return 1; }
@Override
public String display(int depth) {
String prefix = "+".repeat(depth); // Java 11+，兼容性好；旧版本可用 StringBuilder 循环构建
return prefix + name + " (" + size + ")" + System.lineSeparator();
}
@Override
public Component search(String targetName) {
return name.equals(targetName) ? this : null;
}
}重构 Directory 类（Composite 实现）
Directory 负责生成自身标题行，并为每个子组件递归调用 display(depth + 1)，确保子级深度严格 +1：
import java.util.ArrayList;
public class Directory implements Component {
private final String name;
private final ArrayList<Component> children;
public Directory(String name) {
this.name = name;
this.children = new ArrayList<>();
}
public void add(Component component) { children.add(component); }
public void remove(Component component) { children.remove(component); }
@Override
public String getName() { return name; }
@Override
public int getSize() { return children.stream().mapToInt(Component::getSize).sum(); }
@Override
public int getCount() { return children.stream().mapToInt(Component::getCount).sum(); }
@Override
public String display(int depth) {
String prefix = "+".repeat(depth);
StringBuilder sb = new StringBuilder();
sb.append(prefix)
.append(name)
.append(": (count=").append(getCount())
.append(", size=").append(getSize())
.append(")")
.append(System.lineSeparator());
// 为每个子组件递归调用 display(depth + 1)
for (Component child : children) {
sb.append(child.display(depth + 1));
}
return sb.toString();
}
@Override
public Component search(String targetName) {
if (name.equals(targetName)) return this;
return children.stream()
.map(c -> c.search(targetName))
.filter(Objects::nonNull)
.findFirst()
.orElse(null);
}
}测试代码（简洁可靠）
启动入口仅需指定根节点初始深度（通常为 1 或 0，此处用 1 对应首行无前缀、子项带 +）：
public class Test3 {
public static void main(String[] args) {
File holiday = new File("family-holiday", 201);
File wallpaper = new File("wallpaper", 421);
Directory pictures = new Directory("pictures");
Directory personal = new Directory("personal");
Directory misc = new Directory("misc");
Directory dog = new Directory("dog");
dog.add(wallpaper);
personal.add(holiday);
personal.add(misc);
pictures.add(personal);
misc.add(dog);
System.out.print(pictures.display(1)); // ← 初始深度设为 1
}
}✅ 输出结果（完全符合预期）：
pictures: (count=2, size=622) +personal: (count=2, size=622) ++family-holiday (201) ++misc: (count=1, size=421) +++dog: (count=1, size=421) ++++wallpaper (421)
⚠️ 注意事项与最佳实践
-
Java 版本兼容性：String.repeat(int) 是 Java 11 引入的便捷方法。若项目受限于 Java 8，可用以下替代：
String prefix = new String(new char[depth]).replace("\0", "+"); // 或使用 StringBuilder 循环 append - 空格 vs 符号缩进：生产环境常使用空格（如 2/4 空格）提升可读性，原理相同，仅需替换 "+".repeat(depth) 为 " ".repeat(depth)。
- 性能考量：对超深树（>1000 层），频繁字符串拼接可能影响性能，此时建议改用 StringBuilder 在顶层统一构建（如 display(StringBuilder sb, int depth)）。
- 接口设计原则：display(int depth) 比 display(String prefix) 更具语义清晰性与可维护性——深度是结构固有属性，而前缀是渲染表现，二者不应混淆。
通过将层级抽象为整数深度，你不仅解决了当前缩进错乱问题，更强化了组合模式中“递归统一处理”的设计哲学：父组件不关心子组件如何渲染，只负责传递正确的上下文（深度），子组件自主决定如何呈现。这是面向对象分层协作的典型范例。
