原帖发错版块，现在重新发布一下，原帖地址http://bbs.itheima.com/thread-16432-1-1.html
使用再定义一个List集合的方法，那个我会。现在我想还是用原来的那个List集合，使用迭代器的方法，我编写了以下代码：
                                    ArrayList<String> at=new ArrayList<String>();
                 at.add("wer");
                 at.add("wery");
                 at.add("wert");
                 at.add("wer");
                 at.add("wert");
                 at.add("wery");
                 at.add("wer");
                 at.add("werq");
                 int n=0;
                 String str1,str2;
                 
                while(n<at.size())
                 {
                         NN:for(int i =0;i<at.size()-1;i++)
                                        {                                
                                                                     str1=at.listIterator(i).next();
                                 for(int j=i+1;j<at.size();j++)
                                 {
                                         str2=at.listIterator(j).next();
                                         if(str2==str1)
                                         {
                                                 at.listIterator(j).remove();
                                                 break NN;
                                         }
                                 }
                         }
                         n++;
                 }
没有运行成功，提示越界异常，请高手指教！谢谢！

package Test;

import java.util.ArrayList;
class  Demo1
{
        public static void main(String[] args)
        {
                ArrayList<String> at=new ArrayList<String>();
                at.add("wer");
                at.add("wery");
                at.add("wert");
                at.add("wer");
                at.add("wert");
                at.add("wery");
                at.add("wer");
                at.add("werq");
                int n=0;
                String str1,str2;
                  at.size();打印的是集合的长度,我想这位同学长度(从1开始)和索引(从0开始)好像高哦混淆了
                while(n<at.size())
                {
                        NN:for(int i =0;i<at.size()-2;i++)
                                       {                                
                                 str1=at.listIterator(i).next();
                                for(int j=i+1;j<at.size()-1;j++)
                                {
                                        str2=at.listIterator(j).next();
                                        if(str2==str1)
                                        {
                                              at.remove(j);//我想应该改成这样
//                                                at.listIterator(j).remove();//这里会抛IllegalStateException异常.我认为不应该是从迭代器中移除重复元素.应该是在集合中移除才对.
                                                break NN;
                                        }
                                }
                        }
                        n++;
                }
                System.out.println(at);

        }
}

1. int n=0;
   
2.    
   
3.    while(n<at.size())
   
4.    {
   
5.               NN:for(int i =0;i<at.size()-1;i++)
   
6.               {
   
7.                          for(int j=i+1;j<at.size();j++)
   
8.                         {
   
9.                                 ListIterator<String> ll=at.listIterator(i);
   
10.                                if(ll.next()==at.listIterator(j).next())
    
11.                                {
    
12.                                        ll.remove();
    
13.                                        break NN;
    
14.                                 }
    
15.                       }
    
16.               }
    
17.               n++;
    
18.    }

复制代码

      at.listIterator(j).remove();//这里会抛IllegalStateException异常.我认为不应该是从迭代器中移除重复元素.应该是在集合中移除才对.

其实一开始我也犯这个错误了。看毕老师的视频就会知道，在使用迭代器操作集合时，是不能直接对集合进行操作的。下面我把自己解决的方法写出来，代码在上面。

吴琼 发表于 2012-6-30 11:06
package Test;

import java.util.ArrayList;

摘自ArrayList类的api描述

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。