《设计模式就该这样学》之手写自定义迭代器,秒懂迭代器底层原理

本文节选自《设计模式就该这样学》

迭代器模式的UML类图如下图所示。

《设计模式就该这样学》之手写自定义迭代器,秒懂迭代器底层原理_第1张图片

1 手写自定义的集合迭代器

总体来说,迭代器模式是非常简单的。还是以网络课程为例,我们创建一个课程集合,集合中的每一个元素都是课程对象,然后手写一个迭代器,将每一个课程对象的信息都读出来。首先创建集合元素课程Course类。

public class Course {
    private String name;

    public Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

然后创建自定义迭代器Iterator接口。

public interface Iterator {

    E next();

    boolean hasNext();

}

创建自定义的课程集合CourseAggregate接口。

public interface CourseAggregate {

    void add(Course course);

    void remove(Course course);

    Iterator iterator();
}

接着分别实现迭代器接口和集合接口,创建IteratorImpl实现类。

public class IteratorImpl implements Iterator {

    private List list;
    private int cursor;
    private E element;
    public IteratorImpl(List list){
        this.list = list;
    }


    public E next() {
        System.out.print("当前位置" + cursor + ": ");
        element = list.get(cursor);
        cursor ++;
        return element;
    }


    public boolean hasNext(){
        if(cursor > list.size() - 1){
            return false;
        }        
        return true;
    }
}

创建课程集合CourseAggregateImpl实现类。

public class CourseAggregateImpl implements CourseAggregate {

    private List courseList;

    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    public void add(Course course) {
        courseList.add(course);
    }

    public void remove(Course course) {
        courseList.remove(course);
    }

    public Iterator iterator() {
        return new IteratorImpl(courseList);
    }
}

最后编写客户端测试代码。

public static void main(String[] args) {
        Course java = new Course("Java架构");
        Course javaBase = new Course("Java入门");
        Course design = new Course("Java设计模式精讲");
        Course ai = new Course("人工智能");


        CourseAggregate courseAggregate = new CourseAggregateImpl();

        courseAggregate.add(java);
        courseAggregate.add(javaBase);
        courseAggregate.add(design);
        courseAggregate.add(ai);

        System.out.println("-----课程列表-----");
        printCourses(courseAggregate);

        courseAggregate.remove(ai);

        System.out.println("-----删除操作之后的课程列表-----");
        printCourses(courseAggregate);
    }


    public static void printCourses(CourseAggregate courseAggregate){
        Iterator iterator = courseAggregate.iterator();
        while(!iterator.hasNext()){
            Course course = iterator.next();
            System.out.println("《" + course.getName() + "》");
        }
    }

运行结果如下图所示。

《设计模式就该这样学》之手写自定义迭代器,秒懂迭代器底层原理_第2张图片

看到这里,小伙伴们肯定有一种似曾相识的感觉,让人不禁想起每天都在用的JDK自带的集合迭代器。下面就来看源码中是如何运用迭代器的。

2 迭代器模式在JDK源码中的应用

先来看JDK中大家非常熟悉的Iterator源码。

public interface Iterator {
    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

从上面代码中,我们看到定义了两个主要方法hasNext()方法和next()方法,和我们自己写的完全一致。另外,从上面代码中,我们看到remove()方法实现似曾相识。其实是在组合模式中见过的。迭代器模式和组合模式两者似乎存在一定的相似性,组合模式解决的是统一树形结构各层次访问接口,迭代器模式解决的是统一各集合对象元素遍历接口。虽然它们的适配场景不同,但核心理念是相通的。接着来看Iterator的实现类,其实在我们常用的ArrayList中有一个内部实现类Itr,它实现了Iterator接口。

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable {
        ...
        private class Itr implements Iterator {
                int cursor;       // index of next element to return
                int lastRet = -1; // index of last element returned; -1 if no such
                int expectedModCount = modCount;

                public boolean hasNext() {
                        return cursor != size;
               }

               @SuppressWarnings("unchecked")
               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];
                }
                ...
          }
          ...
}

其中,hasNext()方法和next()方法的实现也非常简单,继续往下看,在ArrayList内部还有几个迭代器对Itr进行了进一步扩展,首先看ListItr。

private class ListItr extends Itr implements ListIterator {
            ListItr(int index) {
            super();
            cursor = index;
        }

        public boolean hasPrevious() {
            return cursor != 0;
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor - 1;
        }
     ...
}

它增加了hasPrevious()方法,主要用于判断是否还有上一个元素。另外,还有SubList对子集合的迭代处理。

3 迭代器模式在MyBatis源码中的应用

当然,迭代器模式在MyBatis中也是必不可少的,来看一个DefaultCursor类。

public class DefaultCursor implements Cursor {

    ...

private final CursorIterator cursorIterator = new CursorIterator();
...
}

它实现了Cursor接口,而且定义了一个成员变量cursorIterator,其定义的类型为CursorIterator。继续查看CursorIterator类的源码发现,它是DefaultCursor的一个内部类,并且实现了JDK中的Iterator接口。

 

  爆文阅读

95后阿里P7晒出工资单:狠补了这个,真香...

原来我才是内卷王,闭关3个月肝完Java 7大核心知识,成功斩获字节58万Offer。

太为难我了,阿里面试了7轮(5年经验,拿下P7岗offer)

 《设计模式就该这样学》之使用桥接模式设计复杂的消息系统

《设计模式就该这样学》之趣谈装饰器模式,让你一辈子不会忘

《设计模式就该这样学》之使用策略模式重构电商折扣和支付场景

《设计模式就该这样学》之委派模式详解

你可能感兴趣的