自定义一个迭代器，和使用要点

Iterator迭代器：是一种设计模式，提供了一种方法来对集合，容器进行遍历的方式，不需要关注底层数据结构和数据类型，来达到底层和上层遍历的解耦目的。

集合如何获得一个迭代器：集合要具有Iterator方法需要实现iterable接口，要自定一个迭代器的内部类，类要实现Iterator接口，

 

Iterator：从前往后遍历

hasNext（）判断是否有下一元素

next（）获取当前元素

remove（）删除集合元素

注意：使用上hasNext() 、next()或hasNext()、remove()需要轮询出现

自定义一个Iterator迭代器 

 

import java.util.Arrays;
import java.util.Iterator;

public class DIYIterator<T> implements Iterable<T> {
    private T[] data;
    private int size;
    public DIYIterator(){
        this(10);
    }

    public DIYIterator(int campcity) {
        if (campcity<0){
            try {
                throw new IllegalAccessException("参数异常");
            }catch (IllegalAccessException e){
                e.printStackTrace();
            }
        }
        data = (T[]) new Object[campcity];
        size = 0;
    }
    // 集合是否为满
    private boolean isFull(){
        return size == data.length;
    }
    // 扩容
    private void grow(){
        int newlength = size+size>>1;//1.5倍扩容
        data = Arrays.copyOf(data,newlength);
    }
    // 范围判断
    private boolean checkRange(int index){
        if (index<0||index>size){
            throw new IndexOutOfBoundsException();
        }
        return true;
    }

    @Override
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < size; i++) {
            buffer.append(data[i]+" ");
        }
        return buffer.toString();
    }
    // 添加元素
    public void add (T e){
        if (isFull()){// 数组已满  进行扩容操作
            grow();
        }
        data[size++]=e;
    }
    // 返回指定下标的元素
    public T get(int index){
        checkRange(index);// 进行合法判断
        return data[index];
    }
    // 删除下标为index的元素值，并将其返回
    public T remove(int index ){
        checkRange(index);
        T v = data[index];
        int mov = size - index-1;//计算要移动元素的个数
        System.arraycopy(data,index+1,data,index,mov);
        data[--size] = null;
        return v;
    }
    // 删除指定元素，集合中有些类可以存储null值和null键
    public boolean remove (T e){
        if (e == null){
            for (int i = 0; i < size; i++) {
                if(data[i] == null){
                    int mov = size - i-1;
                    System.arraycopy(data,i+1,data,i,mov);
                    data[--size] = null;
                    return true;
                }
            }
        }else {
            for (int i = 0; i < size; i++) {
                if (e.equals(data[i])){
                    int mov = size - i-1;
                    System.arraycopy(data,i+1,data,i,mov);
                    data[--size] = null;
                    return true;
                }
            }
        }
        return false;
    }

    @Override
    public Iterator<T> iterator() {
        return new Itr();
    }

    class Itr implements Iterator<T>{
        private int afterindex;
        private int beforeindex;

        public Itr() {
            beforeindex = -1;
        }

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

        @Override// 返回当前节点的值
        public T next() {
            int i = afterindex;
            afterindex++;
            T v = data[i];
            beforeindex = i;
            return v;
        }

        @Override
        public void remove() {
            DIYIterator.this.remove(beforeindex);//beforeindex是就当前的元素，
            afterindex = beforeindex;
            beforeindex = -1;
        }
    }

    public static void main(String[] args) {
        DIYIterator<Integer> diyIterator = new DIYIterator<Integer>();
        diyIterator.add(111);
        diyIterator.add(222);
        diyIterator.add(333);
        diyIterator.add(444);
        Iterator<Integer> iterator = diyIterator.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println(next);
//            if (next == 33){
//                iterator.remove();
//            }
        }
        System.out.println(diyIterator.size);

    }
}