import java.util.*;
class ListDemo1
{
        public static void main(String[] args)
        {
                ArrayList a1= new ArrayList();
                a1.add("java01");
                a1.add("java02");
                a1.add("java03");
                a1.add("java04");
               
                for(ListIterator li = a1.listIterator();li.hasNext();)
                {
                        Object obj= li.next();
                        if(obj.equals("java02"))
                        {
                                li.add("java04");//单独打印结果[java01, java02, java04, java03, java04]
                                li.set("java100");//单独打印结果[java01, java100, java03, java04]
                              2个同时存在系统就报IllegalStateException
                        }
                        
                }
               
                sop(a1);
        }
        public static void sop(Object args)
        {
                System.out.println(args);
        }
}
为什么红色2个语句单独存在都可以啊，但是放到一起就会IllegalStateException。这个错误啊，ListIterator这个接口的方法不是可以进行CURD吗？难度一次就只能改 一次吗。那也太不方便了啊，还是我的代码有问题吗。希望知道的人解答下。

这个类还真是没用过啊

不过我查了查文档上面是这么写的：
在这个接口中Interface ListIterator<E>
set
void set(E e)
        Replaces the last element returned by next or previous with the specified element (optional operation). This call can be made only if neither ListIterator.remove nor ListIterator.add have been called after the last call to next or previous.

IllegalStateException - if neither next nor previous have been called, or remove or add have been called after the last call to next or previous.
就是说当你调用了add或者remove方法后就不要再调用set方法了，或者在调用set方法之前调用next方法或者previous方法，将指针移动到相应的位置

原因我看了一下源代码，
这是add方法·：

1. public void add(E e) {
   
2.             checkForComodification();
   
3. 
   
4.             try {
   
5.                 AbstractList.this.add(cursor++, e);
   
6.                 lastRet = -1;
   
7.                 expectedModCount = modCount;
   
8.             } catch (IndexOutOfBoundsException ex) {
   
9.                 throw new ConcurrentModificationException();
   
10.             }
    
11.         }
    
12.     }

复制代码

注意到里面有这样一个变量：lastRet = -1;
当我们调用完add方法，再紧接着调用set方法时：

1. public void set(E e) {
   
2.             if (lastRet == -1)
   
3.                 throw new IllegalStateException();
   
4.             checkForComodification();
   
5. 
   
6.             try {
   
7.                 AbstractList.this.set(lastRet, e);
   
8.                 expectedModCount = modCount;
   
9.             } catch (IndexOutOfBoundsException ex) {
   
10.                 throw new ConcurrentModificationException();
    
11.             }
    
12.         }

复制代码

看到第一个if语句了么？抛异常了
但是当调用next或previous方法时：

1. public E next() {
   
2.             checkForComodification();
   
3.             try {
   
4.                 E next = get(cursor);
   
5.                 lastRet = cursor++;
   
6.                 return next;
   
7.             } catch (IndexOutOfBoundsException e) {
   
8.                 checkForComodification();
   
9.                 throw new NoSuchElementException();
   
10.             }
    
11.         }

复制代码

可以看到lastRet = cursor++;上次操作的指针又移回来了
但是有谁可以帮我解释下，为什么要这样实现呢。。？