JAVA基础——集合Iterator迭代器的实现

一、迭代器概述

  1、什么是迭代器?

  在Java中,有很多的数据容器,对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离,达到解耦的效果。

  在Iterator接口中定义了三个方法:

  

  2、迭代器使用

    public static void main(String[] args)
    {
        List<String> list=new ArrayList<>();
        list.add("abc");
        list.add("edf");
        list.add("ghi");
        for(Iterator<String> it=list.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
    }

 执行结果: 

回到顶部

二、ArrayList的Iterator实现

   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;
       ...
    }

  在ArrayList内部定义了一个内部类Itr,该类实现了Iterator接口。

  在Itr中,有三个变量分别是

  cursor:表示下一个元素的索引位置

  lastRet:表示上一个元素的索引位置

  expectModCount:预期被修改的次数

  下面看一下Itr类实现了Iterator接口的三个方法:

 public boolean hasNext()
 {
     return cursor != size;//当cursor不等于size时,表示仍有索引元素
 }

     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];
    }

  在next()方法中有一个checkForComodification()方法,其实现为:

    final void checkForComodification()
    {
         if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

  可以看到,该函数是用来判断集合的修改次数是否合法。

  在集合内部维护一个字段modCount用于记录集合被修改的次数,每当集合内部结构发生变化(add,remove,set)时,modCount+1。

  在迭代器内部也维护一个字段expectedModCount,同样记录当前集合修改的次数,初始化为集合的modCount值。当我们在调用Iterator进行遍历操作时,如果有其他线程修改list会出现modCount!=expectedModCount的情况,就会报并发修改异常java.util.ConcurrentModificationException。下面为示例代码:

   public static void main(String[] args)
    {
         ArrayList<String> aList=new ArrayList<String>();
         aList.add("bbc");
         aList.add("abc");
         aList.add("ysc");
         aList.add("saa");
         System.out.println("移除前:"+aList);

         Iterator<String> it=aList.iterator();
         while(it.hasNext())
         {
             if("abc".equals(it.next()))
             {
                aList.remove("abc");
             }
         }
         System.out.println("移除后:"+aList);
  }            

  

  上面的代码中,如果我们只使用迭代器来进行删除,则不会出现并发修改异常错误。

  public static void main(String[] args)
    {
       ArrayList<String> aList=new ArrayList<String>();
         aList.add("bbc");
         aList.add("abc");
         aList.add("ysc");
         aList.add("saa");
         System.out.println("移除前:"+aList);

         Iterator<String> it=aList.iterator();
         while(it.hasNext())
         {
            if("abc".equals(it.next()))
            {
              it.remove();
            }
         }
         System.out.println("移除后:"+aList);
  }

  

     public void remove()
     {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
     }

  在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。

回到顶部

三、ListIterator

  上面可以看到,Iterator只提供了删除元素的方法remove,如果我们想要在遍历的时候添加元素怎么办?

  ListIterator接口继承了Iterator接口,它允许程序员按照任一方向遍历列表,迭代期间修改列表,并获得迭代器在列表中的当前位置。

  ListIterator接口定义了下面几个方法:

  

  下面使用ListIterator来对list进行边遍历边添加元素操作:

    public static void main(String[] args)
    {
        ArrayList<String> aList = new ArrayList<String>();
        aList.add("bbc");
        aList.add("abc");
        aList.add("ysc");
        aList.add("saa");
        System.out.println("移除前:" + aList);
        ListIterator<String> listIt = aList.listIterator();
        while (listIt.hasNext())
        {
            if ("abc".equals(listIt.next()))
            {
                listIt.add("haha");
            }
        }
        System.out.println("移除后:" + aList);
    }

  

原文地址:https://www.cnblogs.com/huan-guo/p/8474580.html

时间: 2024-10-12 12:46:24

JAVA基础——集合Iterator迭代器的实现的相关文章

java基础入门-iterator迭代器与集合下标的使用

今天说说集合的iterator迭代器与集合下标的使用 先上代码 import java.util.ArrayList; import java.util.Iterator; public class Test { public Test() { // 初始化List addItemToList(); } private ArrayList<String> list = new ArrayList<String>(); private void addItemToList() { f

Java基础——集合(二)——迭代器、Map集合

接上篇,<Java基础--集合(一)--集合体系和Collection> 四.迭代器的使用 使用步骤: 1.通过集合对象获取迭代器对象. 2.通过迭代器对象判断. 3.通过迭代器对象获取. 迭代器原理 由于多种集合的数据结构不同,所以存储方式不同,所以,取出方式也不同. 这个时候,我们就把判断和获取功能定义在了一个接口中,将来,遍历哪种集合的时候,只要该集合内部实现这个接口即可. 迭代器源码 public interface Iterator { publicabstract boolean

黑马程序员——java基础——集合(Collection)

 黑马程序员--java基础--集合(Collection) ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 集合框架的构成及分类,如下图: 1.为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式. 2.数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的:集合长度是可变的.数组中可以存储基本数据类型,集合只能存储对象. 3.

Java基础——集合(三)——泛型、增强for、工具类

         接上篇,<Java基础--集合(二)--迭代器.Map集合> 六.泛型 (1)定义: 泛型是一种把明确类型的工作放在了创建对象或者调用方法时候才去明确的特殊的类型. (2)格式: <数据类型> ArrayList<String> aList=new ArrayList<String>(); <String> 即表示的是泛型 (3)好处:(掌握) A:解决了黄色警告线问题 B:把运行期间的转换异常给提前到了编译期间 C:优化了程序

java基础-集合笔记

Iterator(foreach) 遍历时只能通过iterator去删除(添加)元素,不能直接通过集合对象删除或添加元素 Set HashSet底层是一个HashMap HashSet添加元素,先判断hashCode,Set中没有相同的则直接添加,Set中有相同的元素,则进一步判断equals,不同则添加,相同则添加不成功 HashSet删除元素,先判断hashCode,相同则再判断equals,equals相同则删除该 List 1.元素是否相同是通过equals方法进行判断的 2.Array

【转】Java学习之Iterator(迭代器)的一般用法 (转)

[转]Java学习之Iterator(迭代器)的一般用法 (转) 迭代器(Iterator) 迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构.迭代器通常被称为“轻量级”对象,因为创建它的代价小. Java中的Iterator功能比较简单,并且只能单向移动: (1) 使用方法iterator()要求容器返回一个Iterator.第一次调用Iterator的next()方法时,它返回序列的第一个元素.注意:iterator()方法是java.l

Java学习之Iterator(迭代器)的一般用法(转)

迭代器(Iterator) 迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构.迭代器通常被称为“轻量级”对象,因为创建它的代价小. Java中的Iterator功能比较简单,并且只能单向移动: (1) 使用方法iterator()要求容器返回一个Iterator.第一次调用Iterator的next()方法时,它返回序列的第一个元素.注意:iterator()方法是java.lang.Iterable接口,被Collection继承. (2)

Java 基础 - 集合

Collection              Collection 集合 在 java.util 包中, 其中 Collection 包含: List: 必须按特定的顺序容纳元素 Set: 不可包含任何重复的元素 注意: Map 不在 Collection 集合中. Collection的主要方法 Boolean add(Object): 如果没添加, 则返回 false(Set 常用) Boolean addAll(Collection) void clear(): 清除所有 Boolean

Java——Collection集合、迭代器、泛型

集合 ——集合就是java提供的一种容器,可以用来存储多个数据. 集合和数组的区别 数组的长度是固定的.集合的长度是可变的. 数组中存储的是同一类型的元素,可以存储基本数据类型值. 集合存储的都是对象.而且对象的类型可以不一致.在开发中一般当对象多的时候,使用集合进行存储. 接口继承关系与实现 集合类存放于 Java.util 包中,主要有 3 种:set(集).list(列表包含 Queue)和 map(映射). 1. **Collection:**Collection 是集合 List.Se