疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

迭代器Iterator与语法糖for-each


 

 
一、为什么需要迭代器
 
设计模式迭代器
迭代器作用于集合,是用来遍历集合元素的对象。迭代器迭代器不是Java独有的,大部分高级语言都提供了迭代器来遍历集合。实际上,迭代器是一种设计模式:
 
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部的表示。
 
迭代器封装了对集合的遍历,使得不用了解集合的内部细节,就可以使用同样的方式遍历不同的集合。
 
暴露细节的遍历
 
要理解封装遍历的好处,必须理解暴露细节的遍历带来的坏处。
以下是两个不同的集合接口,第一个是自定义集合,第二个是JDK的java.util.List
 
public interface IUserDefinedList<E> {
 
    int length();
 
    E getElement(int index);
}
public interface List<E> {
 
    int size();
 
    E get(int index);
}
分别使用for循环对它们进行遍历:
 
// 自定义List
for (int i = 0, len = ul.length(); i < len; i++) {
    System.out.println(ul.getElement(i));
}
// java.util.List
for (int i = 0, size = ll.size(); i < size; i++) {
    System.out.println(ll.get(i));
}
遍历集合的代码与具体集合类型紧密耦合,不同类型的集合,必须写出不同的遍历代码,不可重用。紧耦合在良好的代码设计中是大忌,这时需要将遍历逻辑抽离,封装。这就是迭代器模式了。
 
二、封装遍历-迭代器
 
面向接口编程
 
面向接口编程是基本的设计原则,迭代器模式将遍历封装到接口,然后各个集合类可以以实现接口,或者组合接口实现类的方式,将遍历封装。
 
迭代器接口如下:
 
public interface Iterator<E> {
    boolean hasNext();
    E next();
}
然后就可以以统一的方式遍历集合:
 
Iterator it = aIterator;
while(it.hasNext) {
    it.next();
}
因为集合都实现了Iterator接口,所以以上的遍历代码是可以重用的,并且与具体集合类型松耦合。
 
Java迭代器
 
Java提供的Iterator原理大致相同:
 
java迭代器接口
 
忽略Java8提供的默认方法forEachRemaining(),java迭代器多了可以移除上一个元素的remove()方法。
 
Java集合中有很多迭代器的具体实现,以ArrayList为例:
 
ArrayList迭代器实现
 
ArrayList的迭代器是以内部类的方式实现的,每次调用List的iterator()方法,都会得到一个基于当前ArrayList对象状态的迭代器:
 
public Iterator<E> 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<String> ls = new ArrayList<>();
Iterator<String> it = ls.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
    ls.ensureCapacity(10); // 改变了集合对象modCount的值,下次调用next 抛出异常
}
三、语法糖for-each
 
java中的for-each:
 
List<String> 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<T> {
    
    Iterator<T> iterator();
    
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}
忽略默认方法,该接口要求集合实现iterator()方法,并返回一个迭代器对象Iterator。这也是java中的集合通过实现Iterable接口,组合Iterator来提供迭代器,并不通过直接实现Iterator接口的方式来提供集合迭代器的原因了。所以java集合迭代器的直接用法都如下:
 
List<String> ls = new ArrayList<>();
Iterator<String> it = ls.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}
for-each的编译器实现
 
The Java® Language Specification 对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 < #a.length; #i++) {
    {VariableModifier} TargetType Identifier = #a[#i];
    Statement
}
    
以上参考 The enhanced for statement
 
另外,使用javap命令,反编译字节码,可以看到编译器是怎样处理for-each的。
 
public class Test {
    public static void main(String[] args) {
        List<String> ls = new ArrayList<>();
        for (String s: ls) {
        }
    }
}
以上源文件对应class文件的反编译汇编为:
 
C:OTHERSWorkingideaWorkutils_practicesrcmainjava>javap -c patternadapterjava_exampleTest.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."<init>":()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."<init>":()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遍历,势必会跑出空指针异常。
 
for-each中不能改变遍历的集合
因为在使用迭代器遍历集合时,不能够改变集合,所以for-each遍历改变集合时,同样会引发ConcurrentModificationException异常。