为什么一下程序的结果是这样的：
code：
import java.util.*;
public class Test {
  public static void main (String args[]) {
   String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
    int i=0;
   List list = new LinkedList(Arrays.asList(elements));
   ListIterator iter = list.listIterator(list.size());
   while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
   } } }

输出结果：
Lenovo
Apple
为什么 MOTO 没输出来？ 但是如果我没用set的话 就有输出

因为迭代器遍历集合里的元素时，previous()方法被调用一次之后，下一次再调用它时，它读取的将是集合中的下一个元素。

你在while的每次循环里调用了两次previous方法，但只有一次打印输出，所以只看到一半的元素。

1. import java.util.*;
   
2. 
   
3. public class ClassTest {
   
4.         public static void main(String args[]) {
   
5.                 String elements[] = { "Apple", "Samsung", "Lenovo", "MOTO" };
   
6.                 int i = 0;
   
7.                 List list = new LinkedList(Arrays.asList(elements));
   
8.                 ListIterator iter = list.listIterator(list.size());
   
9.                 while (iter.hasPrevious()) {
   
10.                         //为了避免之前的情况，每次循环内部，只调用一次previous()方法：
    
11.                         String s = (String)iter.previous();
    
12.                         System.out.println("original:"+s);
    
13.                         if (s.equals("Samsung")) {
    
14.                                 iter.set("aa");
    
15.                         }
    
16.                 }
    
17.                
    
18.                 //用增强for循环重新遍历，打印看看：
    
19.                 for(Object o : list) {
    
20.                         System.out.println(o);
    
21.                 }
    
22.         }
    
23. }

复制代码

肯定是这样啊，iter.previous()指的是前一个元素，你在if (iter.previous().equals("Samsung"))这里调用了iter.previous()，判断的是"MOTO“，输出时又写了一遍，它就输出了前边的 "Lenovo”，一次类推，后边的也是

1. public static void main(String[] args) {
   
2.                 String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
   
3.             int i=0;
   
4.            List list = new LinkedList(Arrays.asList(elements));
   
5.            ListIterator iter = list.listIterator(list.size());
   
6.            while(iter.hasPrevious()){
   
7.                    Object o = iter.previous(); //把前一个对象，存起来。
   
8.                if (o.equals("Samsung")){
   
9.                    iter.set("aa");
   
10.               }
    
11.                System.out.println(o);  
    
12.            }
    
13.         }

复制代码

while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){//调用一次
           iter.set("aa");
      }
       System.out.println(iter.previous());//调用一次

你连续调用两次,MOTO肯定看不见。

不对啊！我按照你这个程序吧set去了输出的结果就是  "Apple", "Samsung", "Lenovo",

1. import java.util.*;
   
2. 
   
3. public class Test {
   
4.         public static void main(String args[]) {
   
5.                 String elements[] = { "Apple", "Samsung", "Lenovo", "MOTO" };
   
6.                
   
7.                 @SuppressWarnings("unused")
   
8.                 int i = 0;
   
9.                 List<String> list = new LinkedList<String>(Arrays.asList(elements));
   
10.                 ListIterator<String> iter = list.listIterator(list.size());
    
11.                 while (iter.hasPrevious()) {
    
12.         //                if (iter.previous().equals("Samsung")) {
    
13.         //                        iter.set("aa");
    
14.         //                }
    
15.                         System.out.println(iter.previous());
    
16.                 }
    
17.         }
    
18. }
    

复制代码

下面是我查询的API你仔细看看，如果你发现我哪回答的不好 希望得到你的回复！！！！

previous()返回列表中的前一个元素。可以重复调用此方法来迭代列表，或混合调用 next 来前后移动（注意交替调用 next 和 previous 将重复返回相同的元素）。

返回：
列表中的上一个元素。

void set(E e)用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。只有在最后一次调用 next 或 previous 后既没有调用 ListIterator.remove 也没有调用 ListIterator.add 时才可以进行该调用。

参数：
e - 用于替换 next 或 previous 返回的最后一个元素的元素。

为什么一下程序的结果是这样的：
code：
import java.util.*;
public class Test {
  public static void main (String args[]) {
   String elements[] = {"Apple", "Samsung", "Lenovo", "MOTO"};
    int i=0;
   List list = new LinkedList(Arrays.asList(elements));
   ListIterator iter = list.listIterator(list.size());
   while(iter.hasPrevious()){
       if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
   } } }
iter.hasPrevious()是从后面判断元素是否存在，iter.previous()是获取元素
hasnext（）是从前面判断元素是否存在，next（）是获得元素。
iter.previous()每调用一次就会向前移动一次，而在
if (iter.previous().equals("Samsung")){
           iter.set("aa");
      }
       System.out.println(iter.previous());  
中调用了两次所以只有两个值。