集合--迭代器Iterator

迭代器

• 什么是迭代器？
   Iterator是一种设计模式，其作用是就是提供一种方法对一个容器对象中的各个元素进行访问，而又不暴露该对象容器的内部细节。即提供了一种方法，来对集合、容器进行遍历的方式。
   在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。

• 方法介绍：

1. boolean hasNext()：判断集合是否还有元素  true，还存在元素
2. E next()：返回当前数据
3. void remove()：删除元素

注意： 使用上hashNext、next需轮循出现----》hashNext、remove。

• 使用迭代器实现ArrayList的遍历：

public class ArrayListIteratorDemo {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(10);
        arrayList.add(12);
        arrayList.add(13);
     
        //从前往后访问
        System.out.println("next:");
        ListIterator<Integer> listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            listIterator.nextIndex();//找元素对应的索引位置
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();//10 12 13
        
        //从后往前访问
        System.out.println("previous:");
        ListIterator<Integer> listIterator1 = arrayList.listIterator(arrayList.size());
        while (listIterator1.hasPrevious()){
            listIterator1.previousIndex();
            System.out.print(listIterator1.previous()+ " ");
        }
        System.out.println();//13 12 10
        
        //通过for循环遍历
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i) + " ");
        }
        System.out.println();
        
        //通过迭代器遍历
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Integer value = iterator.next();
            System.out.println(value +" ");
        }
        System.out.println();
        System.out.println("size :"+ arrayList.size() );
        
        //增强for循环 foreach  ===》底层是通过迭代器实现的
        for (Integer i:arrayList) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

• 自定义实现迭代器
  要自定义迭代器类：类要具有iterator 方法需要实现iterator接口， 自定义迭代器需要实现iterator接口。
  注意： 迭代器调用引起会并发异常ConcurrentModificationException，原因：集合本身修改会引起modCount版本号修改，而迭代器本身的版本号副本并未改变，因此会抛出并发异常。
  在这里插入图片描述

 /**
             * Exception in thread "main" java.util.ConcurrentModificationException  并发异常
             * 	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
             * 	at java.util.ArrayList$Itr.remove(ArrayList.java:873)
             * 	at ArrayList190219.main(ArrayList190219.java:46)
             */

手动实现：
public class DIYArrayList0219<T> implements  Iterable<T> {
    private T[] data;//存储元素数组
    private int size;//元素个数

    public DIYArrayList0219(){
        this(10);
    }
    public DIYArrayList0219(int campcity){
        if (campcity < 0){
            try {
                throw new IllegalAccessException("参数异常");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        data = (T[]) new Object[campcity];
        size = 0;
    }
    //判满
    public boolean isFull(){
        if (size == data.length){
            return true;
        }
        return false;
    }
    //判空
    public boolean isEmpty(){
        if (data.length == 0){
            return true;
        }
        return false;
    }
    //扩容
    public void grow(){
        int newlength = size + size >> 1;//1.5倍
        data = Arrays.copyOf(data,newlength);
    }
    //合法性判断
    public boolean rangeCheck(int index){
        if(index < 0 || index >= size){
            return false;
        }
        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 T[] add(T e){
        if (isFull()){
            grow();
        }
        data[size++] = e;
        return data;
    }
    //获取指定下标的元素
    public T get(int index){
        rangeCheck(index);
        return data[index];
    }
    //删除指定下标的元素
    public T remove(int index){
        rangeCheck(index);
        T oldNum = data[index];
        int numMoved = size - index - 1;
        if (numMoved > 0 ){
            System.arraycopy(data,index + 1,data,index,numMoved);
            data[-- size] = null;
        }
        return oldNum;
    }
    //删除指定元素
    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 beforeindex; //下一个元素的位置
        private int afterindex;//前一个位置
        @Override
        public boolean hasNext() {
            return afterindex != size;
        }

        @Override
        public T next() {//获取当前数据，并指针后移一位
            int i = afterindex;
            afterindex = afterindex + 1;
            T v = data[i];
            beforeindex = i;
            return v;
        }

        @Override
        public void remove() {
            DIYArrayList0219.this.remove(beforeindex);
            afterindex = beforeindex;
            beforeindex = -1;
        }
    }

    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(10);
        arrayList.add(20);
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Integer value = iterator.next();
            System.out.println(value + " ");
        }
        iterator.remove();
    }
}