前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >迭代器模式(控制访问集合中的元素)

迭代器模式(控制访问集合中的元素)

作者头像
幺鹿
发布2018-08-21 15:40:14
1.3K0
发布2018-08-21 15:40:14
举报
文章被收录于专栏:Java呓语

正文

JDK中已经为我们提供了大量实现了迭代器的容器类。 因此我们可以不用关心,诸如:LinkedlistArrayList之间的差别,却仍能保障我们完成工作。

现在我们需要思索,JDK是怎么做到这一切的?现在让我们先利用迭代器实现一个数组类型Array,这个类型需要支持添加、移除、遍历操作。

实现

STEP 1

定义迭代器接口,实现该接口的类拥有迭代器职责。这叫好像在20年前,家门口停了一辆小汽车,别人都会知道你是万元户一样。

代码语言:javascript
复制
public interface Iterable<T> {
    Iterator<T> iterator();
}

STEP 2

定义迭代器对象,除却基本的hasNextnext方法。额外定义了addremove方法,这会辅助我们操作集合中的元素。

注意:迭代器不仅仅为了{迭代},而是为了{操作}集合中的元素。

代码语言:javascript
复制
public interface Iterator<E> {
    boolean hasNext();

    E next();

    boolean add(E e);

    boolean addAll(Collection<? extends E> e);

    boolean remove(E e);
}

STEP 3

实现一个数组Array模拟数组的操作,所有访问集合中元素的操作全权委托给iterator对象。Array并不关心操作元素的细节,它只向外暴露操作接口,对收到的请求转发给iterator处理。

代码语言:javascript
复制
public class Array<E> implements Iterable<E> {

    private transient Iterator<E> iterator;

    public Array() {
        this.iterator = iterator();
    }

    public Array(Collection<? extends E> collection) {
        this.iterator = iterator();
        this.iterator.addAll(collection);
    }

    @Override
    public Iterator<E> iterator() {
        synchronized (this) {
            if (iterator == null) {
                iterator = new ArrayIteratorImpl<>();
            }
        }
        return iterator;
    }

    public void add(E e) {
        this.iterator.add(e);
    }

    public void addAll(Collection<? extends E> e) {
        this.iterator.addAll(e);
    }

    public void remove(E e) {
        this.iterator.remove(e);
    }

}

STEP 4

定义迭代器实现类,使用接口抽象迭代器是为了满足开闭原则,这样Array可以随时更换迭代器而不会影响现有的接口。

ArrayIteratorImpl迭代器实现了对数组的添加、移除操作,如何分配元素、选择用什么容器存储、遍历的顺序、甚至是否启用并行操作,这些对于Array都是不可感知的。

代码语言:javascript
复制
public class ArrayIteratorImpl<E> implements Iterator<E> {

    private transient Object[] elementData = {};
    private transient static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    private static final int DEFAULT_CAPACITY = 10;
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    protected transient int modCount = 0;
    private int size;

    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

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

    @Override
    public E next() {
        int i = cursor;
        if (i >= size)
            throw new IllegalArgumentException("");
        Object[] elementData = this.elementData;
        if (i >= elementData.length)
            throw new IllegalArgumentException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    @Override
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        lastRet = -1;
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> e) {
        final Object[] a = e.toArray();
        final int numNew = e.size();
        ensureCapacityInternal(this.size + numNew);
        System.arraycopy(a, 0, elementData, size, numNew);
        this.size += numNew;
        lastRet = -1;
        return numNew != 0;
    }

    @Override
    public boolean remove(E o) {
        lastRet = -1;
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

}

STEP 5

客户端调用测试

代码语言:javascript
复制
public class Client {

    public static void main(String[] args) {
        Array<String> array = new Array();
        array.add("清华大学");
        array.add("北京大学");
        array.add("浙江大学");
        array.add("武汉大学");
        array.add("西安交通大学");
        array.add("上海交通大学");
        array.add("人民大学");


        Iterator<String> iterator = array.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);
        }
    }
}

总结

迭代器模式属于行为模式类别。

迭代器本质:控制访问集合中的元素

迭代器模式.png

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2017.02.22 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 正文
  • 实现
    • STEP 1
      • STEP 2
        • STEP 3
          • STEP 4
            • STEP 5
            • 总结
            相关产品与服务
            容器服务
            腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
            领券
            问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档