java iterator 遍历组合模式的核心做法是:让 composite 和 leaf 类共同实现 java.util.iterator 接口,并在 composite 中维护一个内部迭代器实例来委托实际的遍历逻辑。这样做可以让客户端统一使用 for-each 循环或 iterator 方法访问树形结构中的节点,而无需关心当前处理的是叶子节点还是组合节点。

Iterator 在组合模式中如何定义与实现
在组合模式中,Iterator 的实现通常集中在 Composite 节点上,因为 Leaf 节点只有一个元素,其迭代器实现非常简单(返回自身或单元素列表)。Composite 节点需要管理子节点集合,并负责协调子节点的迭代过程。常见的实现方式是使用内部类或私有类来实现 Iterator 接口,这样可以将迭代逻辑封装在组件内部,避免暴露内部数据结构。

import java.util.*;
// 组件接口
interface Component {
void operation();
Iterator<component> getIterator();
}
// 叶子节点
class Leaf implements Component {
private String name;
public Leaf(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("Leaf: " + name);
}
@Override
public Iterator<component> getIterator() {
return new Iterator<component>() {
private boolean hasNext = true;
@Override
public boolean hasNext() {
return hasNext;
}
@Override
public Component next() {
if (hasNext) {
hasNext = false;
return Leaf.this;
}
throw new NoSuchElementException();
}
};
}
}
// 组合节点
class Composite implements Component {
private List<component> children = new ArrayList();
private String name;
public Composite(String name) {
this.name = name;
}
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
@Override
public void operation() {
System.out.println("Composite: " + name);
for (Component child : children) {
child.operation();
}
}
@Override
public Iterator<component> getIterator() {
return new CompositeIterator(children.iterator());
}
// 内部迭代器类
private class CompositeIterator implements Iterator<component> {
private Iterator<component> iterator;
public CompositeIterator(Iterator<component> iterator) {
this.iterator = iterator;
}
@Override
public boolean hasNext() {
while (!iterator.hasNext()) {
if (iterator.hasNext()) {
break;
}
return false;
}
return true;
}
@Override
public Component next() {
if (hasNext()) {
return iterator.next();
}
throw new NoSuchElementException();
}
}
}
public class Main {
public static void main(String[] args) {
Composite root = new Composite("root");
root.add(new Leaf("leaf1"));
root.add(new Leaf("leaf2"));
Composite subComposite = new Composite("subComposite");
subComposite.add(new Leaf("leaf3"));
root.add(subComposite);
// 使用 Iterator 遍历
Iterator<component> iterator = root.getIterator();
while (iterator.hasNext()) {
Component component = iterator.next();
component.operation();
}
}
}</component></component></component></component></component></component></component></component></component>
Iterator 遍历时如何处理嵌套的子节点
当遍历到 Composite 节点时,需要递归地获取其子节点的迭代器,并将这些子节点的迭代器合并到一个统一的迭代器中。这可以通过维护一个迭代器栈来实现,每次调用 next() 时,先检查当前迭代器是否有下一个元素,如果没有则弹出栈顶迭代器并压入新子节点的迭代器。这种深度优先的遍历方式可以确保所有节点都被访问到,且顺序符合预期。
FilePond 是一个 JavaScript 文件上传库,支持通过拖拽、粘贴和 API 方式处理文件、目录、URL 和 Data URI。它包含内置的图像优化功能、异步分块上传功能,并提供了适用于 React、Vue、Angular 和 Svelte 的适配器。

import java.util.*;
interface Component {
void operation();
Iterator<component> getIterator();
}
class Leaf implements Component {
private String name;
public Leaf(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("Leaf: " + name);
}
@Override
public Iterator<component> getIterator() {
return Collections.singletonList(this).iterator();
}
}
class Composite implements Component {
private List<component> children = new ArrayList();
private String name;
public Composite(String name) {
this.name = name;
}
public void add(Component component) {
children.add(component);
}
@Override
public void operation() {
System.out.println("Composite: " + name);
for (Component child : children) {
child.operation();
}
}
@Override
public Iterator<component> getIterator() {
return new RecursiveCompositeIterator(children);
}
private class RecursiveCompositeIterator implements Iterator<component> {
private Stack<iterator>> stack = new Stack();
private Component current;
public RecursiveCompositeIterator(List<component> components) {
stack.push(components.iterator());
}
@Override
public boolean hasNext() {
while (!stack.isEmpty()) {
Iterator<component> it = stack.peek();
if (it.hasNext()) {
current = it.next();
if (current instanceof Composite) {
Composite composite = (Composite) current;
stack.push(composite.getIterator());
}
return true;
} else {
stack.pop();
}
}
return false;
}
@Override
public Component next() {
if (hasNext()) {
return current;
}
throw new NoSuchElementException();
}
}
}
public class Main {
public static void main(String[] args) {
Composite root = new Composite("root");
root.add(new Leaf("leaf1"));
Composite sub1 = new Composite("sub1");
sub1.add(new Leaf("leaf2"));
root.add(sub1);
Composite sub2 = new Composite("sub2");
sub2.add(new Leaf("leaf3"));
sub1.add(sub2);
System.out.println("Depth-first traversal:");
Iterator<component> iterator = root.getIterator();
while (iterator.hasNext()) {
Component component = iterator.next();
component.operation();
}
}
}</component></component></component></iterator></component></component></component></component></component>
基于程序中某个输入、条件或结果的具体问题
在上述代码中,当输入为包含多层嵌套的 Composite 结构时,RecursiveCompositeIterator 能够正确地按照深度优先的顺序遍历所有节点。例如,当 root 包含 sub1,而 sub1 又包含 sub2 时,遍历顺序为 root -> leaf1 -> sub1 -> leaf2 -> sub2 -> leaf3。这种遍历方式确保了每个节点只被访问一次,且父子关系保持正确。如果需要在遍历时修改结构(如删除节点),则需要小心处理迭代器的状态,避免 ConcurrentModificationException。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










