具体语言实现不同，这里是一些语言无关的点

• 如果你在遍历时往数组增加数据，会导致遍历不完整（因为增加了新成员长度变了），或者死循环（因为总是有新的进去）

• 如果在遍历时删除数据，则会导致数组访问越界（因为长度缩短了，指针指向了一个已经标示为空的区域）

• 如 @Terry_139061 的答案，如果你只是在遍历时修改这个节点本身的数据，一般来说是安全的（当然需要看具体场景）

从java的角度回答这个问题， Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

 for(int i=0; i<array.size(); i++) { ... get(i) ... }

• 客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

• 更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

    
     for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
    
   

  　- 奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

• 当使用Iterator对集合元素进行迭代的时候，collection并不是把集合元素本身传给了迭代变量，而是把集合元素的值传给了迭代变量。所以修改迭代变量的值对集合元素本身的值没有任何改变。迭代器Iterator不保存对象，它依附于Collection对象，仅用于遍历集合。迭代器Iterator采用的是快速-失败(fail-fast)机制，一旦在迭代的过程中检测到该集合已经被修改，程序立即引发java.util.ConcurrentModificationException，而不是显示修改后的结果。这样可以避免共享资源而引发的潜在问题。

 public class TestCollections {  

    public static void main(String[] args) {  
        List<String> list = new ArrayList<String>();  
        for (int i = 0; i < 10; i++) {  
            list.add("hello_" + i);  
        }  
        Iterator<String> iterator = list.iterator();  
        while (iterator.hasNext()) {  
            String str = iterator.next();  
            System.out.println(str);  
            if (str.equals("hello_5")) {  
//                iterator.remove();  
                list.remove(str);  
            }  
            str = "hehe";  
        }  
        System.out.println(list);  
    }  
}

• 执行 { str = "hello" } 语句,对外部的元素没有任何影响,执行 iterator.remove()会删除当前的迭代对象. 执行list.remove(str) ,会报java.util.ConcurrentModificationException ,因为他检测到集合的元素被修改了.

可以修改呀，下面的程序会打印3个 aaaaa

 List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("!");
for (int i = 0; i < list.size(); i++) {
    list.set(i, "aaaaa");
}
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

你是用什么方法遍历的，请贴出代码来，好帮你分析

你的问题描述得不太准确，标签是 java 和 lisp ，只写过一点 racket 代码就不谈论 lisp 了，以下默认修改为 list 的 add/remove 操作

• 首先， java 里面有很多种 list ：

    
     　　java.util.ArrayList;
  　　java.util.LinkedList;
  　　java.util.Stack;
  　　java.util.Vector;
  　　java.util.concurrent.CopyOnWriteArrayList;
    
   

  其中 CopyOnWriteArrayList 在遍历的时候修改是不会出错的，实现方法是读写分离，参考维基 Copy-on-write

• 其次， java 里面有好几种遍历方式：

    
     for
  iterator
  foreach
    
   

  • for ，在 for 循环中修改并没有问题，除非你把要访问的对象删除，数组越界，或者一直add生成无穷序列

  • iterator ，你用 iterator.remove() 是不会有问题的，因为 iterator.remove() 会设置

        
         this.expectedModCount = ArrayList.this.modCount;//（1）
        
       

    这样之后遍历执行 iterator.next() 就不会抛异常

        
         public E next() {
    this.checkForComodification();
    ...
    }
    
    final void checkForComodification() {
    if(ArrayList.this.modCount != this.expectedModCount) {
        throw new ConcurrentModificationException();
    }
    }
        
       

  • foreach ，本质上是隐式的 iterator （可以用 javap -c 比较字节码），由于没有重新设置 expectedModCount ，当你使用 list.remove() 后遍历执行 iterator.next() 时就会报 ConcurrentModificationException

• 最后，这里面有一个特别的地方，就如果删除的是 list 里倒数第二个值，这样触发 hasNext() 的时候结果正好为 false 退出循环不继续执行 next() 也就不会报错

    
     public boolean hasNext() {
          return this.cursor != ArrayList.this.size;
      }
    
   

PS：使用的JDK是java-8-openjdk-amd64