迭代器的原理

Iterator(迭代器)<E> 接口:

                   所属包：java.util

  成员方法：

                        E  next ( ); //获取下一个元素

                        boolean hasNext ( );    // 判断是否有元素，有true,没有false

                       void remove( );     //获取谁，删除谁

例子：

import java.util.ArrayList;
import java.util.Iterator;
 public class test01 {
   public static void main(String[] args) {
     ArrayList<Integer> list =new ArrayList<>();
     list.add(111);
     list.add(222);
     list.add(25);
     Iterator<Integer> it = list.iterator();
     while(it.hasNext()) {
         Integer next = it.next();
         System.out.println(next);
     }
   }
}

注意： 1.通过迭代器遍历集合的失败，不能通过集合对象增删元素

        2.如果要删除元素可以通过迭代器对象删除

增强for循环：

         语法： for(数据类型 对象名 ： 要遍历的集合名称){

                              //对象名就是我们获取元素

                               //数据类型写接口的泛型

                                   }

例子：

   ArrayList<Integer> list =new ArrayList<>();
     list.add(111);
     list.add(222);
     list.add(25);
     for (Integer i : list) {
        System.out.println(i);    
    }

增强for循环： 遍历集合的时候，底层就是迭代器

迭代器实现原理：

我们看下java Collection中迭代器是怎样实现的

//迭代器角色，仅仅定义遍历集合接口

public interface Iterator<E> {
     
       boolean hasNext();

        E next();

         void remove()；}

ArrayList类的iterator方法：

public class ArrayList<E> extends AbstractList<E>{
 public Iterator<E> iterator() {
        return new Itr();
    }
}

简述ArrayList迭代器的实现原理

 class ArrayList<E>{
   //成员变量
    private int size;//记录元素个数
   private Object[] elementData;//集合底层用来保存元素的数组
                     
 //成员 内部类
private class Itr implements Iterator<E>{ 
    //成员内部类的成员方法
       int cursor;    // index of next element to return
       int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}
         
         //判断是否有元素
        public boolean hasNext() {
            //成员内部类变量和外部成员变量进行比较
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
         //获取下一个元素
        public E next() {
            checkForComodification();
             //把成员内部类成员变量赋给i
            int i = cursor;
             //在于Size进行比较
            if (i >= size)
                throw new NoSuchElementException();
             //ArrayList.this.elementData ：如果成员内部类的成员方法和外部类成员方法同名
             // 外部类.this.外部类成员方法（访问外部类的成员方法）
         Object[] elementData = ArrayList.this.elementData;//赋给外部成员变elelmentdata数组
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
             //给i+1赋给cursor
            cursor = i + 1;
            return (E) elementData[lastRet = i];//相当于返回给数组的索引值加1
        }

对ArrayList迭代器原理的主要的表达：

             //ArrayList迭代器主要核心 
            class ArrayList<E>{
                    //成员变量
                    private int size;//记录元素个数
                    private Object[] elementData;//集合底层用来保存元素的数组
                     
                     
                    //成员 内部类
                    private class Itr implements Iterator<E> {
                        //成员内部类的成员变量
                        private int cursor;
                        
                        public boolean hasNext(){
                            return cursor!=size;
                        }
                        
                        public E next(){
                            return (E)elementData[cursor++];
                        }
                    }
                }