import java.util.Iterator;
import java.util.List ;
import java.util.ArrayList;

public class Demo01 {
        public static void main(String[] args) {
                List<String> allList = new ArrayList<String>() ;
                allList.add("cyc") ;
                allList.add("wff") ;
                allList.add("_") ;
                allList.add("abc") ;
               
                System.out.println("之前"+allList.size());
                Iterator<String> iter = allList.iterator();
                while(iter.hasNext()) {
                        String str = iter.next() ;
                        if("_".equals(str)) {
                                iter.remove() ;
                        } else {
                                System.out.println(str + "、");
                        }
                }
                System.out.println("之后"+allList.size());
        }
}


/**
使用iterator中的remove（）方法删除一个元素后，allList的长度不应该变化，应该是iterator的对象长度变化
两者有什么联系？？
*/

iter 指向的还是allList中的元素，所以remove之后allList的长度也发生了变化

Iterator<String> iter = allList.iterator(); 只是对象传递地址，并不是把allList中的值copy一份到iter对象中

楼主可以自己看看源码，看看迭代器的remove方法是怎么写的，，                                    

1. public Iterator<E> iterator() {
   
2.         return new Itr();
   
3.     }
   
4. 
   
5.     /**
   
6.      * An optimized version of AbstractList.Itr
   
7.      */
   
8.     private class Itr implements Iterator<E> {
   
9.         int cursor;       // index of next element to return
   
10.         int lastRet = -1; // index of last element returned; -1 if no such
    
11.         int expectedModCount = modCount;
    
12. 
    
13.         public boolean hasNext() {
    
14.             return cursor != size;
    
15.         }
    
16. 
    
17.         @SuppressWarnings("unchecked")
    
18.         public E next() {
    
19.             checkForComodification();
    
20.             int i = cursor;
    
21.             if (i >= size)
    
22.                 throw new NoSuchElementException();
    
23.             Object[] elementData = ArrayList.this.elementData;
    
24.             if (i >= elementData.length)
    
25.                 throw new ConcurrentModificationException();
    
26.             cursor = i + 1;
    
27.             return (E) elementData[lastRet = i];
    
28.         }
    
29. 
    
30.         public void remove() {
    
31.             if (lastRet < 0)
    
32.                 throw new IllegalStateException();
    
33.             checkForComodification();
    
34. 
    
35.             try {
    
36.                 ArrayList.this.remove(lastRet);
    
37.                 cursor = lastRet;
    
38.                 lastRet = -1;
    
39.                 expectedModCount = modCount;
    
40.             } catch (IndexOutOfBoundsException ex) {
    
41.                 throw new ConcurrentModificationException();
    
42.             }
    
43.         }
    
44. 
    
45.         final void checkForComodification() {
    
46.             if (modCount != expectedModCount)
    
47.                 throw new ConcurrentModificationException();
    
48.         }
    
49.     }

复制代码

这是arrylist的实现iterator接口的源码，我想你说的iterator的长度就应该是游标cursor应该回到了上一个lastRet
至于你说的alllist长度没有发生变化，应该发生变化了

张稳 发表于 2014-4-13 18:15
这是arrylist的实现iterator接口的源码，我想你说的iterator的长度就应该是游标cursor应该回到了上一个las ...

为什么我们找见的源码会不一样？

1.   @Override public Iterator<E> iterator() {
   
2.         return new ArrayListIterator();
   
3.     }
   
4. 
   
5.     private class ArrayListIterator implements Iterator<E> {
   
6.         /** Number of elements remaining in this iteration */
   
7.         private int remaining = size;
   
8. 
   
9.         /** Index of element that remove() would remove, or -1 if no such elt */
   
10.         private int removalIndex = -1;
    
11. 
    
12.         /** The expected modCount value */
    
13.         private int expectedModCount = modCount;
    
14. 
    
15.         public boolean hasNext() {
    
16.             return remaining != 0;
    
17.         }
    
18. 
    
19.         @SuppressWarnings("unchecked") public E next() {
    
20.             ArrayList<E> ourList = ArrayList.this;
    
21.             int rem = remaining;
    
22.             if (ourList.modCount != expectedModCount) {
    
23.                 throw new ConcurrentModificationException();
    
24.             }
    
25.             if (rem == 0) {
    
26.                 throw new NoSuchElementException();
    
27.             }
    
28.             remaining = rem - 1;
    
29.             return (E) ourList.array[removalIndex = ourList.size - rem];
    
30.         }
    
31. 
    
32.         public void remove() {
    
33.             Object[] a = array;
    
34.             int removalIdx = removalIndex;
    
35.             if (modCount != expectedModCount) {
    
36.                 throw new ConcurrentModificationException();
    
37.             }
    
38.             if (removalIdx < 0) {
    
39.                 throw new IllegalStateException();
    
40.             }
    
41.             System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);
    
42.             a[--size] = null;  // Prevent memory leak
    
43.             removalIndex = -1;
    
44.             expectedModCount = ++modCount;
    
45.         }
    
46.     }

复制代码

霍振鹏 发表于 2014-4-13 18:27
为什么我们找见的源码会不一样？

不知道额，版本的问题？