Iterator和ListIterator接口的使用和区别

1.Iterator接口

1.1.Iterator接口概述

java.util.Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration，迭代器允许调用者在迭代过程中移除元素。

每一个集合都有自己的数据结构(就是容器中存储数据的方式)，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口，使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。
也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。

1.2Iterator接口方法：

我们使用next迭代出的元素是原来集合元素的拷贝其实Java集合保存的元素实质上对象元素的引用，并不是对象的引用,也就是说，迭代的对象是集合里边引用的拷贝，还是一个引用，那么如果集合里边保存的元素可以改变，那么可以使用迭代器修改里边的对象

1.3Iterator接口的使用实例：

1.迭代List集合的例子：

package untl1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyIterator {
    public static void main(String[] args) {
        List<Integer> iterator=new ArrayList();//只要是List或者Set实现类都可以这么用
        p1.add(1);
        p1.add(2);
        p1.add(3);
        p1.add(4);
        for ( Iterator<Integer> a=iterator.iterator();a.hasNext();) {
            Integer b=a.next();
            System.out.println(b);
        }
    }
   }
运行结果：
1
2
3
4   

2.迭代Map集合例子（通过所有的结点（结点都是一个Entry对象））：

package untl1;
import java.util.*;
public class MyIterator {
    public static void main(String[] args) {
     Map<Integer,String> p1=new HashMap<>();
        p1.put(1,"AA");
        p1.put(2,"BB");
        p1.put(3,"CC");
        p1.put(4,"DD");
        Set<Map.Entry<Integer,String>>  ss=p1.entrySet();
        //把HashMap里边的键值对看作一个对象，存放在Set集合里边再在Set集合里边得到迭代器，以此遍历
        for (Iterator<Map.Entry<Integer,String>> a = ss.iterator(); a.hasNext();) {
            Map.Entry p2=a.next();
            System.out.println(p2.getKey()+" "+p2.getValue());
        }
    }
   }
运行结果：
1 AA
2 BB
3 CC
4 DD

当然我们也可以通过键集合来遍历：

package untl1;
import java.util.*;
public class MyIterator {
    public static void main(String[] args) {
     Map<Integer,String> p1=new HashMap<>();
        p1.put(1,"AA");
        p1.put(2,"BB");
        p1.put(3,"CC");
        p1.put(4,"DD");
        Set<Integer>  ss=p1.keySet();
        for (Iterator<Integer> a = ss.iterator(); a.hasNext();) {
           Integer p2=a.next();
            System.out.println(p2+" "+p1.get(p2));
        }
    }
   }
运行结果：
1 AA
2 BB
3 CC
4 DD

3.我们使用迭代器边迭代边移除集合里边的元素：

package untl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class MyIterator {
    public static void main(String[] args) {
        int i=0;
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc","ddd");
        for (Iterator<String> iterator=list.iterator();iterator.hasNext();)
        {
            String str=iterator.next();
            System.out.println(str);

            if(i==1)
            iterator.remove();
            i++;
        }
        System.out.printf("ArrayList里边的内容为：");
        System.out.println(list);
    }
}
运行结果：
aaa
bbb
ccc
ddd
ArrayList里边的内容为：[aaa, ccc, ddd]

2.ListIterator接口

2.1ListIterator接口概述：

java.util.ListIterator是一个功能更加强大的迭代器， 它继承于Iterator接口，只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator， 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。

2.2ListIterator接口的特点：

1.允许我们向前、向后两个方向遍历 List；
2.在遍历时修改 List 的元素；
3.遍历时获取迭代器当前游标所在位置。

2.3ListIterator接口常用方法：

2.4.ListIterator接口的使用例子：

package untl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
public class MyIterator {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc","ddd");
        ListIterator<String> listIterator=list.listIterator();
        for (;listIterator.hasNext();)//从前往后遍历
        {
            String str=listIterator.next();
            System.out.println(str);
        }
        System.out.println("----------------------------------------");
        listIterator.add("eee");//添加一个元素
        ListIterator<String> listIterator1=list.listIterator();
        //由于上一个迭代器已经指向最后一个元素所以我们从新获取一个迭代器
        boolean bool=listIterator1.hasPrevious();//判断是否前面有元素
        System.out.println(bool);
        String str=listIterator1.next();//把迭代指针向后移动一位
        System.out.println(str);
        System.out.println(listIterator1.hasPrevious());
        System.out.println("----------------------------------------");
        listIterator1.set("000");//把刚刚迭代所返回的元素进行替换
        ListIterator<String> listIterator2=list.listIterator();
        //在获得指向第一个元素的迭代器
        for (;listIterator2.hasNext();)
        {
            System.out.println(listIterator2.next());
            System.out.println(listIterator2.nextIndex());
            System.out.println(listIterator2.previousIndex());
        }
        System.out.println("----------------------------------------");
        //由于listIterator2已经指向最后一个元素，我们利用下面代码从后往前遍历
        for (;listIterator2.hasPrevious();)
        {
            String str3=listIterator2.previous();
            System.out.println(str3);
        }
    }
}
运行结果：
aaa
bbb
ccc
ddd
----------------------------------------
false
aaa
true
----------------------------------------
000
1
0
bbb
2
1
ccc
3
2
ddd
4
3
eee
5
4
----------------------------------------
eee
ddd
ccc
bbb
000

Process finished with exit code 0

Iterator和ListIterator接口的区别

1.Iterator 可以遍历 Set 和 List集合，而 ListIterator 只能遍历List。
2.Iterator 只能 单向遍历，而 ListIterator 可以 双向遍历（向前/后遍历）。
3.ListIterator 实现 Iterator 接口，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

转载：https://blog.csdn.net/qq_45737068/article/details/105923045