学完ListIterator,就产生了有没有可能发生死循环的可能，我开始试验。这是我认为会死循环的代码

1. package com.itheima;
   
2. import java.util.*;
   
3. public class ListIteratorDemo {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7.                 ArrayList<String> al=new ArrayList<String>();
   
8.                 al.add("lisi01");
   
9.                 al.add("lisi02");
   
10.                 al.add("lisi03");
    
11.                 al.add("lisi04");
    
12.                 list(al);
    
13.         }
    
14.         public static void list(ArrayList<String> al){
    
15.                 sop(al);
    
16.                 for(ListIterator<String> lt=al.listIterator(0);lt.hasNext();){
    
17.                         String obj=lt.next();
    
18.                         sop(obj);                                //在这里加上输出语句，如果添加的新元素会出现在这里，一定会是死循环
    
19.                         if(obj=="lisi02")               
    
20.                                 lt.add("lisi02");
    
21.                 }
    
22.                 sop(al);
    
23.         }
    
24.         public static void sop(Object o)
    
25.         {
    
26.                 System.out.println(o);
    
27.         }
    
28. 
    
29. }

复制代码

输出结果是

发现添加新元素后，果然迭加器会跳过该元素，这样就消除了我的顾虑，
但是我还不放心，又改了，核心代码

1. for(ListIterator<String> lt=al.listIterator(al.size());lt.hasPrevious();){
   
2.                         String obj=lt.previous();
   
3.                         sop(obj);                                //在这里加上输出语句，如果添加的新元素会出现在这里，一定会是死循环
   
4.                         if(obj=="lisi02")               
   
5.                                 lt.add("lisi02");
   
6.                 }

复制代码

结果奇迹发生了

把检索方式反一下，照理应该和next()是一样的处理方式，结果真出现死循环了。
我想求解：这是jdk编写者的遗漏还是另有原因。

ListIterator接口中几个方法的工作原理，API文档写得很清楚了。add()方法添加元素会导致：a subsequent call to previous would return the new element. 死循环是非常正常的了。

如果再看源码就会知道，你认为“把检索方式反一下，照理应该和next()是一样的处理方式”是错误的。ListIterator几个方法的实现依赖于List中元素的下标。add新元素，下标都+1，但next和previous的方向不同就会带来不同的结果

这个算不上失误。就像死循环不能说是循环语句的设计失误，只是人为利用了其工作原理造出来死循环这个现象（有意或无意）

a subsequent call to previous would return the new element.
看到这句，足矣！
谢谢您的耐心解答