java for 迭代器_Java基础-迭代器Iterator与语法糖for-each

痛定思痛。 2022-11-06 00:03 182阅读 0赞

迭代器Iterator与语法糖for-each

一、为什么需要迭代器

设计模式迭代器

迭代器作用于集合，是用来遍历集合元素的对象。迭代器不是Java独有的，大部分高级语言都提供了迭代器来遍历集合。实际上，迭代器是一种设计模式：迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

迭代器封装了对集合的遍历，使得不用了解集合的内部细节，就可以使用同样的方式遍历不同的集合。

暴露细节的遍历

要理解封装遍历的好处，必须理解暴露细节的遍历带来的坏处。

以下是两个不同的集合接口，第一个是自定义集合，第二个是JDK的java.util.Listpublic interface IUserDefinedList \{    int length();    E getElement(int index);

\}public interface List \{    int size();    E get(int index);

分别使用for循环对它们进行遍历：// 自定义Listfor (int i = 0, len = ul.length(); i

System.out.println(ul.getElement(i));

\}// java.util.Listfor (int i = 0, size = ll.size(); i

System.out.println(ll.get(i));

遍历集合的代码与具体集合类型紧密耦合，不同类型的集合，必须写出不同的遍历代码，不可重用。紧耦合在良好的代码设计中是大忌，这时需要将遍历逻辑抽离，封装。这就是迭代器模式了。

二、封装遍历-迭代器面向接口编程

面向接口编程是基本的设计原则，迭代器模式将遍历封装到接口，然后各个集合类可以以实现接口，或者组合接口实现类的方式，将遍历封装。

迭代器接口如下：public interface Iterator \{    boolean hasNext();    E next();

然后就可以以统一的方式遍历集合：Iterator it = aIterator;while(it.hasNext) \{

it.next();

因为集合都实现了Iterator接口，所以以上的遍历代码是可以重用的，并且与具体集合类型松耦合。

Java迭代器

Java提供的Iterator原理大致相同：

![AAffA0nNPuCLAAAAAElFTkSuQmCC][]

java迭代器接口

忽略Java8提供的默认方法forEachRemaining()，java迭代器多了可以移除上一个元素的remove()方法。

Java集合中有很多迭代器的具体实现，以ArrayList为例：

![AAffA0nNPuCLAAAAAElFTkSuQmCC][]

ArrayList迭代器实现

ArrayList的迭代器是以内部类的方式实现的，每次调用List的iterator()方法，都会得到一个基于当前ArrayList对象状态的迭代器：public Iterator iterator() \{    return new Itr();

next()方法：public E next() \{

checkForComodification();    int i = cursor;    if (i >= size)        throw new NoSuchElementException();

Object\[\] elementData = ArrayList.this.elementData;    if (i >= elementData.length)        throw new ConcurrentModificationException();

cursor = i + 1;    return (E) elementData\[lastRet = i\];

每次调用next()方法，都会调用final void checkForComodification() \{   if (modCount != expectedModCount)        throw new ConcurrentModificationException();

检查所迭代的列表对象是否被修改过，modCount是外部类的一个字段，当调用外部类的add, remove, ensureCapacity等方法，都会改变改字段的值，而expectedModCount是内部类Itr初始化迭代器实例时，使用modeCount赋值的字段。这样，在使用迭代器过程中，如果对正在迭代的对象调用了add, remove, ensureCapacity等方法，再去调用迭代器的next()，就会引发ConcurrentModificationException异常了。

一个诱发异常的例子：ArrayList ls = new ArrayList<>();

Iterator it = ls.iterator();while (it.hasNext()) \{

System.out.println(it.next());

ls.ensureCapacity(10); // 改变了集合对象modCount的值，下次调用next 抛出异常\}

三、语法糖for-each

java中的for-each：List ls = new ArrayList<>();for (String s: ls) \{

System.out.println(s);

for-each其实只是java提供的语法糖。语法糖是编程语言提供的一些便于程序员书写代码的语法，是编译器提供给程序员的糖衣，编译时会对这些语法特殊处理。语法糖虽然不会带来实质性的改进，但是在提高代码可读性，提高语法严谨性，减少编码错误机会上确实做出了很大贡献。

Java要求集合必须实现Iterable接口，才能使用for-each语法糖遍历该集合的实例。

JDK对该接口的描述是：Implementing this interface allows an object to be the target of \* the "for-each loop" statement.

接口如下：public interface Iterable \{

Iterator iterator();

default void forEach(Consumer super T> action) \{

Objects.requireNonNull(action);        for (T t : this) \{

action.accept(t);

default Spliterator spliterator() \{        return Spliterators.spliteratorUnknownSize(iterator(), 0);

忽略默认方法，该接口要求集合实现iterator()方法，并返回一个迭代器对象Iterator。这也是java中的集合通过实现Iterable接口，组合Iterator来提供迭代器，并不通过直接实现Iterator接口的方式来提供集合迭代器的原因了。所有java集合迭代器的直接用法都如下：List ls = new ArrayList<>();

Iterator it = ls.iterator();while (it.hasNext()) \{

System.out.println(it.next());

for-each的编译器实现

for-each遍历集合，实际上被翻译如下：for (I \#i = Expression.iterator(); \#i.hasNext(); ) \{

\{VariableModifier\} TargetType Identifier =

(TargetType) \#i.next();

Statement

当然，除了集合，for-each还可以遍历数组，翻译如下：T\[\] \#a = Expression;

L1: L2: ... Lm:for (int \#i = 0; \#i

\{VariableModifier\} TargetType Identifier = \#a\[\#i\];

Statement

另外，使用javap命令，反编译字节码，可以看到编译器是怎样处理for-each的。public class Test \{    public static void main(String\[\] args) \{

List ls = new ArrayList<>();        for (String s: ls) \{

以上源文件对应class文件的反编译汇编为：C:\\OTHERS\\Working\\ideaWork\\utils\\Z\_practice\\src\\main\\java>javap -c pattern\\adapter\\java\_example\\Test.class

Compiled from "Test.java"public class pattern.adapter.java\_example.Test \{  public pattern.adapter.java\_example.Test();

Code:       0: aload\_0       1: invokespecial \#1                  // Method java/lang/Object."":()V

4: return

public static void main(java.lang.String\[\]);

Code:       0: new           \#2                  // class java/util/ArrayList

3: dup       4: invokespecial \#3                  // Method java/util/ArrayList."":()V

7: astore\_1       8: aload\_1       9: invokeinterface \#4,  1            // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

14: astore\_2      15: aload\_2      16: invokeinterface \#5,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z

21: ifeq          37

24: aload\_2      25: invokeinterface \#6,  1            // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;

30: checkcast     \#7                  // class java/lang/String

33: astore\_3      34: goto          15

37: return\}

不用关注全部汇编细节，只需要看到InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;就知道实际上是使用了迭代器。

至于数组的for-each，也可以通过观察class文件的汇编代码理解。

四、最佳实践for-each遍历的集合对象不能为null

既然对集合的for-each遍历实际上是使用迭代器，会调用集合对象的iterator()方法获得迭代器，那么，对null集合的for-each遍历，就会在null集合对象上调用方法，势必会抛出空指针异常。

for-each遍历时不能改变正在遍历的集合

因为在使用迭代器遍历集合时，不能够改变集合，所以for-each遍历时改变集合，同样会引发ConcurrentModificationException异常。

作者：理查德成

链接：https://www.jianshu.com/p/186bf11ffe51

[AAffA0nNPuCLAAAAAElFTkSuQmCC]:

java for 迭代器_Java基础-迭代器Iterator与语法糖for-each

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Iterator迭代器

相关 java for迭代iterator,java之Iterator迭代器增强for循环

相关 java for 迭代器_Java基础-迭代器Iterator与语法糖for-each

相关 java Iterator 迭代器

相关 Iterator迭代器

相关 java基础__迭代器iterator/iterable接口

相关 Java迭代器Iterator

相关 Iterator(迭代器)

相关 Iterable 迭代器

相关 java基础之迭代器（Iterator）