class  Demo
{
        public static void main(String[] args)
        {
                ArrayList al=new ArrayList();
                al.add("java01");
                al.add("java02");
                al.add("java03");
                sop(al);
                Iterator it =al.iterator();
                while (it.hasNext())
                {
                        Object obj=it.next();
                        if (obj.equals("java02"))
                        {
                                it.remove();
                        }
                        sop("obj="+obj);
                }
                sop(al);
                //老师说将java02的引用从集合中删除了 。这个引用是角标吗？
                //删除后那在打印集合的时候像数组一样没有al[1]了吗？
                //应该不是吧也就是集合是怎么调用它的元素的？

        }
}//在并发异常中如要用listIterator操作删除集合的元素，集合进行访问的时候不也会出错吗？

首先要理解的是ArrayList 是动态的数组，
这样增加元素是会增加数组的长度，减少元素是会缩短数组的长度。
要实现这样的效果就要new 出新数组。
换句话说把原来那个数组里的元素遍历后重新放到一个新的数组中，这样是否可以理解？

贴个动态数组的例子，希望楼主能够理解我的观点：

1. /*
   
2. 现在要求定义一个数组(Array)，里面定义了一个整型数组，但是此整型数组属于动态分配大小，
   
3. 即：所以大小由程序指定，并在此基础上实现以下的两个子类。
   
4.         *反转类：可以将数组的内容反转排列
   
5.         *排序类：可以对数组进行排序的操作
   
6. */
   
7. 
   
8. import java.util.ArrayList;
   
9. import java.util.Arrays;
   
10. import java.util.Collections;
    
11. import java.util.Comparator;
    
12. import java.util.List;
    
13. 
    
14. public class MyDynamicArray {
    
15. 
    
16.         public static void main(String []args){
    
17.        
    
18.                 ReverseArray al = new ReverseArray();
    
19.                 SortArray sa = new SortArray();
    
20. 
    
21.                 al.add(1);
    
22.                 al.add(15);
    
23.                 al.add(7);
    
24.                 al.add(19);
    
25.                 al.add(5);
    
26.                 al.add(29);
    
27.                 al.add(9);
    
28. /*
    
29.                                 al.add(7);
    
30.                 al.add(19);
    
31.                 al.add(5);
    
32.                 al.add(29);
    
33.                 al.add(9);
    
34.                 sa.add(7);
    
35.                 sa.add(19);
    
36.                 sa.add(5);
    
37.                 sa.add(29);
    
38.                 sa.add(9);   */
    
39.                
    
40.                 sa.add(1);
    
41.                 sa.add(15);
    
42.                 sa.add(7);
    
43.                 sa.add(19);
    
44.                 sa.add(5);
    
45.                 sa.add(29);
    
46.                 sa.add(9);
    
47. 
    
48. 
    
49.                 System.out.println(al.toString());
    
50.                 //System.out.println(al);
    
51.                 al.reverse();
    
52.                 System.out.println(al.toString());
    
53.                
    
54.                 System.out.println(sa.toString());
    
55.                 sa.sort();
    
56.                 System.out.println(sa.toString());
    
57. 
    
58.         }
    
59. }
    
60. 
    
61. 
    
62. class Array {
    
63.         private int [] array = new int[10];
    
64.         private int size =0;
    
65.        
    
66.         public int getSize() {
    
67.                 return size;
    
68.         }
    
69.         public void setSize(int size) {
    
70.                 this.size = size;
    
71.         }
    
72.          
    
73.         public int get(int index){
    
74.                 return array[index];
    
75.         }
    
76.        
    
77.         public int set(int index, int element){
    
78.                 array[index] = element;
    
79.                 return get(index);
    
80.         }
    
81.        
    
82.         public boolean add(int i){
    
83.                 size++;
    
84.                 System.out.println(size);
    
85.                 if(size>10)
    
86.                         array = copyArray(array);
    
87. 
    
88.                 array[size-1] = i;
    
89.                 return true;
    
90.         }
    
91.        
    
92.         private int[] copyArray(int[] array){
    
93.                        
    
94.                 int []array1 = new int[array.length+1];
    
95.                
    
96.                 for(int i = 0; i<array.length;i++){
    
97.                         array1[i] = array[i];
    
98.                 }
    
99.                 return array1;
    
100.         }
     
101.        
     
102.         public boolean remove(int index){
     
103.                 if(index>=size)
     
104.                         return false;
     
105.                 else{
     
106.                         int[] array1 = new int[size - 1];
     
107.                         for(int i = 0, count = 0; i<size;i++){
     
108.                                 if(i == index)
     
109.                                         continue;
     
110.                                 array1[count++] = array[i];                               
     
111.                         }
     
112.                         array = array1;
     
113.                         size--;
     
114.                         return true;
     
115.                 }
     
116.         }
     
117.        
     
118.         @Override
     
119.         public String toString() {
     
120.                 // TODO Auto-generated method stub
     
121.                 Integer [] intList = new Integer[size];
     
122.                
     
123.                 for(int i = 0;i<size;i++){//注意角标越界。
     
124.                         intList[i] = get(i);
     
125.                 }
     
126.                 List list = Arrays.asList(intList);
     
127.                 return list.toString();
     
128.         }       
     
129. }
     
130. 
     
131. class ReverseArray extends Array{
     
132.        
     
133.         public void reverse(){
     
134.                 int size = getSize();
     
135.                 int half = size>>1;
     
136.                
     
137.                 for(int i =0,x=0; i< half;i++){
     
138.                         x = get(i);
     
139.                         set(i, get(size-1-i));
     
140.                         set(size-1-i,x);
     
141.                 }
     
142.         }
     
143. 
     
144.        
     
145.         public void sort(){
     
146.                 int size = getSize();
     
147. 
     
148.                 for(int z=0,x=0;z<size-1;z++){
     
149.                         for(int y=z+1; y<size;y++){//y=z+1; 而不是1；
     
150.                                 if(get(z)>get(y)){
     
151.                                         x = get(z);
     
152.                                         set(z, get(y));
     
153.                                         set(y,x);
     
154.                                 }
     
155.                         }
     
156.                 }
     
157.         }
     
158.        
     
159. }
     
160. 
     
161. class SortArray extends Array{
     
162.         public void sort(){
     
163.                 int size = getSize();
     
164. 
     
165.                 for(int z=0,x=0;z<size-1;z++){
     
166.                         for(int y=z+1; y<size;y++){
     
167.                                 if(get(z)>get(y)){
     
168.                                         x = get(z);
     
169.                                         set(z, get(y));
     
170.                                         set(y,x);
     
171.                                 }
     
172.                         }
     
173.                 }
     
174.         }
     
175. }

复制代码

我是这样理解的，在ArrayList集合中，"java02"这个对象有一个集合中的名字(索引、角标)，当使用Iterator迭代器进行hasNext判断后，迭代器将这个集合中的名字告诉了外界，obj这时找到了对应的集合中元素。

在使用remove进行判断移除时，迭代器仅仅是将这个对象元素在集合中移除了，但是这个对象还是在的，他被obj指向，所以while循环内打印出来的相当于是集合中原来所有元素的遍历结果。

出循环后，打印的al就是迭代器进行了一轮操作后的集合元素

如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！