迭代器模式與訪問者模式，都用于遍歷集合；迭代器模式關注遍歷；訪問者模式關注操作。

迭代器模式

定義

迭代器模式(Iterator Pattern)是一種行為型設計模式，它提供一種方法順序訪問一個聚合對象中的各個元素，而又不暴露該對象的內部表示。

核心角色

1. 迭代器(Iterator)：定義訪問和遍歷元素的接口
2. 具體迭代器(ConcreteIterator)：實現(xiàn)迭代器接口，跟蹤當前遍歷位置
3. 聚合(Aggregate)：定義創(chuàng)建迭代器對象的接口
4. 具體聚合(ConcreteAggregate)：實現(xiàn)創(chuàng)建迭代器的接口

應用場景

• 需要統(tǒng)一遍歷不同集合結構的對象時
• 需要為聚合對象提供多種遍歷方式的時候
• 需要隱藏聚合對下那個的內部結構時
• 需要支持對聚合對象的并行遍歷時

使用

迭代器模式的典型實現(xiàn)：

• 抽象迭代器

  /**
   * 迭代器模式：迭代器接口
   * @Author：lyj
   * @Date：2025/5/20 11:47
   */
  public interface Iterator<T> {
      /**
       * 判斷是否還有下一個元素
       * @return
       */
      public boolean hasNext();
      /**
       * 獲取下一個元素
       * @return
       */
      public T next();
  }
  

• 抽象聚合

  /**
   * 迭代器模式：聚合接口
   * @Author：lyj
   * @Date：2025/5/20 11:49
   */
  public interface Container<T> {
      /**
       * 獲取迭代器
       * @return
       */
      Iterator<T> getIterator();
  }
  

• 具體聚合+具體迭代器

  /*
  * 迭代器模式：具體聚合
   * @Date：2025/5/20 11:50
   */
  public class NameRepository implements Container<String> {
      public List<String> names = new ArrayList<>();
  
      public NameRepository(String[] names) {
         for (String name : names){
             this.names.add(name);
         }
      }
      /**
       * 獲取迭代器
       * @return
       */
      @Override
      public Iterator<String> getIterator() {
          return new NameIterator();
      }
  
  
      /**
       *  迭代器模式：具體迭代器
       * @Author：lyj
       * @Date：2025/5/20 11:54
       */
      public class NameIterator implements Iterator<String> {
          private int index = 0;
  
          /**
           * 判斷是否還有下一個元素
           * @return
           */
          @Override
          public boolean hasNext() {
              return index < names.size();
          }
  
          /**
           * 獲取下一個元素
           * @return
           */
          @Override
          public String next() {
              if (this.hasNext() ) {
                  return names.get(index++);
              }
              return "";
          }
      }
  }
  

運行客戶端

String[] names = {"張三","李四","王五","趙六"};
NameRepository nameRepository = new NameRepository(names);
// 迭代
Iterator<String> iterator = nameRepository.getIterator();
while (iterator.hasNext()){
	System.out.println("Name:" +iterator.next());
}

運行結果：

訪問者模式

定義

訪問者模式(Visitor Pattern)允許在不修改已有類結構的情況下定義新的操作，將數(shù)據(jù)結構和數(shù)據(jù)操作分離。

核心角色

1. Visitor（訪問者接口）：聲明訪問具體元素的visit方法
2. ConcreteVisitor（具體訪問者）：實現(xiàn)訪問者接口的具體操作
3. Element（元素接口）：定義accept方法接受訪問者
4. ConcreteElement（具體元素）：實現(xiàn)元素接口的具體類
5. ObjectStructure（對象結構）：包含元素的集合，提供訪問入口

應用場景

• 需要對復雜對象結構（如組合結構）執(zhí)行多種不相關的操作
• 需要在不改變元素類的前提下增加新的操作
• 需要對對象結構中的元素執(zhí)行多種不同且不相關的操作

使用

電腦配件的顯示

• 訪問者接口 (電腦訪問者（鍵盤、顯示屏）)

  /**
   * 訪問者模式-訪問者接口：電腦
   * @Author：lyj
   * @Date：2025/5/22 10:59
   */
  public interface ComputerPartVisitor {
      /**
       * 訪問者訪問電腦
       * @param keyyboard
       */
      public void visit(Keyyboard keyyboard);
      /**
       * 訪問者訪問顯示器
       * @param monitor
       */
      public void visit(Monitor monitor);
  }
  

• 具體訪問者 (顯示電腦部件信息)

  /**
   * 訪問者模式-具體訪問者：顯示部件信息
   * @Date：2025/5/22 11:22
   */
  public class ComputerPartDisplayVistor implements ComputerPartVisitor {
      @Override
      public void visit(Keyyboard keyyboard) {
          System.out.println("顯示鍵盤信息");
      }
  
      @Override
      public void visit(Monitor monitor) {
          System.out.println("顯示顯示器信息");
      }
  }
  

• 元素接口 (電腦接口)

  /**
   * 訪問者模式-元素接口 ：電腦
   * @Author：lyj
   * @Date：2025/5/22 10:54
   */
  public interface ComputerPart {
      /**
       * 接受訪問者
       * @param visitor
       */
      public void accept(ComputerPartVisitor visitor);
  }
  

• 具體元素 （鍵盤、顯示屏）

  /**
   * 訪問者模式-具體元素：鍵盤
   * @Date：2025/5/22 11:01
   */
  public class Keyyboard implements ComputerPart {
      @Override
      public void accept(ComputerPartVisitor visitor) {
          visitor.visit(this);
      }
  }
  

  /**
   * 訪問者模式-具體元素：顯示器
   * @Author：lyj
   * @Date：2025/5/22 11:02
   */
  public class Monitor implements ComputerPart{
      @Override
      public void accept(ComputerPartVisitor visitor) {
          visitor.visit(this);
      }
  }
  

• 對象結構

/**
 * 訪問者模式-對象結構：電腦
 * @Author：lyj
 * @Date：2025/5/22 11:20
 */
public class Computer implements ComputerPart {
    ComputerPart[] parts;
    public Computer(){
        parts = new ComputerPart[]{
                new Keyyboard(),
                new Monitor()
        };
    }
    @Override
    public void accept(ComputerPartVisitor visitor) {
       for (ComputerPart part:parts){
           part.accept(visitor);
       }
    }
}

運行客戶端：

Computer computer = new Computer();
computer.accept(new ComputerPartDisplayVistor());

運行結果：