2. 程式人生 > >ArrayList與迭代器模式

ArrayList與迭代器模式

阿新 • • 發佈：2019-02-03

本文主要講解迭代器模式在ArrayList原始碼中的使用。

迭代器模式(Iterator Pattern)：提供一種方法來訪問聚合物件中的各個元素，而不用暴露這個物件的內部表示。在Java中，ArrayList的迭代器有兩種：Iterator和ListIterator。

Iterator

迭代器是一個用來遍歷並選擇序列中的物件。Java的Iterator的只能單向移動。

例子

在寫如何實現之前，先看一個使用迭代器Iterator的小例子：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public
 
 class Test {

    @org.junit.Test
    public void test() {
        List list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = (String) iterator.next();
            System.out.println(str);
            iterator.remove();
        }
        System.out.println(list.size());
    }
}

執行結果

1
2
3
4
0

方法

  • iterator()，list.iterator()用來從容器物件中返回一個指向list開始處的迭代器。
  • next(),獲取序列中的下個元素。
  • hasNext(),檢查序列中向下是否還有元素。
  • remove(),將迭代器最近返回的一個元素刪除。這也意味著呼叫remove()前需要先呼叫next()。

實現

在設計模式（16）-迭代器模式這一文章中曾講過，迭代器模式中有四個角色：

  • 抽象聚合類Aggregate。在ArrayList的Iterator迭代器實現中，沒有抽象聚合類。雖然它實現了AbstractList，實現了List，但它向外部提供的建立迭代器的方法iterator()是它自己的。
  • 具體聚合類ConcreteAggregate。在ArrayList的Iterator迭代器實現中，指的是ArrayList。
  • 抽象迭代器Iterator。在ArrayList的Iterator迭代器實現中，指的是Iterator介面。
  • 具體迭代器ConcreteIterator。在ArrayList中的Iterator迭代器實現中，指的是Itr。

ArrayList程式碼片段

public class ArrayList<E>
{
    /**
     * 儲存新增到ArrayList中的元素。
     * ArrayList的容量就是該陣列的長度。
     * 該值為DEFAULTCAPACITY_EMPTY_ELEMENTDATA 時，當第一次新增元素進入ArrayList中時，陣列將擴容值DEFAULT_CAPACITY。
     * 被標記為transient，在物件被序列化的時候不會被序列化。
     */
    transient Object[] elementData; 

    // ArrayList的實際大小（陣列包含的元素個數）。
    private int size;

    /**
     * 返回一個用來遍歷ArrayList元素的Iterator迭代器
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * AbstractList.Itr的最優化的版本
     */
    private class Itr implements Iterator<E> {
        int cursor;       // 下一個要返回的元素的索引
        int lastRet = -1; // 最近的被返回的元素的索引; 如果沒有返回-1。
        int expectedModCount = modCount;
        /**
         * 判斷是否有下一個元素
        */
        public boolean hasNext() {
            //如果下一個要返回的元素的索引不等於ArrayList的實際大小，則返回false
            return cursor != size;
        }

        /**
         * 返回下一個元素
         */
        @SuppressWarnings("unchecked")
        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];
        }
        /**
         * 刪除最近的一個被返回的元素
         */
        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();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

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

Iterator

import java.util.function.Consumer;

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Itr.java

作為ArrayList的內部類。請在上文中的[ArrayList.java程式碼片段]中檢視。

ListIterator

ListIterator是一個更加強大的Iterator的子型別。它只能用於各種List類的訪問。它最大的優點是可以雙向移動。它還可以產生相對於迭代器在列表中指向的當前位置的前一個和後一個元素的索引，並且可以使用set()方法替換它訪問過的最後一個元素。

例子

在寫如何實現之前，先看一個使用列表迭代器ListIterator的小例子：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test {

    @org.junit.Test
    public void test() {
        List list = new ArrayList<>();
        list.add("0");
        list.add("1");
        list.add("2");
        list.add("3");
        ListIterator iterator = list.listIterator();
        System.out.println("--------------------向下遍歷--------------------");
        while (iterator.hasNext()) {
            int nextIndex = iterator.nextIndex();
            String next = (String) iterator.next();
            //int previousIndex = iterator.previousIndex();
            System.out.println("當前元素："+next+"，當前元素索引："+nextIndex/*+"，前一個元素的索引"+previousIndex*/);
        }
        System.out.println("--------------------向上遍歷--------------------");
        while (iterator.hasPrevious()) {
            int previousIndex = iterator.previousIndex();
            String previous = (String) iterator.previous();
            System.out.println("當前元素："+previous+"，當前元素索引："+previousIndex);
        }
        System.out.println("-----------測試set()和listIterator(n)----------");
        System.out.println(list);
        iterator = list.listIterator(3);
        while(iterator.hasNext()){
            iterator.next();
            iterator.set("5");
        }
        System.out.println(list);
    }
}

執行結果

-------向下遍歷-------
當前元素：0，當前元素索引：0
當前元素：1，當前元素索引：1
當前元素：2，當前元素索引：2
當前元素：3，當前元素索引：3
-------向上遍歷-------
當前元素：3，當前元素索引：3
當前元素：2，當前元素索引：2
當前元素：1，當前元素索引：1
當前元素：0，當前元素索引：0
-------測試set()和listIterator(n)-------
[0, 1, 2, 3]
[0, 1, 2, 5]

方法

  • listIterator()，list.iterator()用來從容器物件中返回一個指向list開始處的迭代器。
  • listIterator(n)，list.iterator()用來從容器物件中返回一個指向列表索引為n的迭代器。
  • next(),獲取序列中的下個元素，執行後索引+1。
  • previous(),獲取序列中的上個元素，執行後索引-1。
  • nextIndex,獲取序列中的下個元素的索引。
  • previousIndex,獲取序列中的下個元素的索引。
  • hasNext(),檢查序列中向下是否還有元素。
  • hasPrevious(),檢查序列中向上是否還有元素。
  • remove(),從列表中刪除next()或previous()返回的最後一個元素。這也意味著呼叫remove()前需要先呼叫next()或者previous()。
  • add(E e): 將指定的元素插入列表，插入位置為迭代器當前位置之前。
  • set(E e)：從列表中將next()或previous()返回的最後一個元素返回的最後一個元素更改為指定元素e。

實現

在設計模式（16）-迭代器模式這一文章中曾講過，迭代器模式中有四個角色：

  • 抽象聚合類Aggregate。在ArrayList的ListIterator迭代器實現中，沒有抽象聚合類。雖然它實現了AbstractList，實現了List，但它向外部提供的建立迭代器的方法listIterator()是它自己的。
  • 具體聚合類ConcreteAggregate。在ArrayList的ListIterator迭代器實現中，指的是ArrayList。
  • 抽象迭代器Iterator。在ArrayList的ListIterator迭代器實現中，指的是ListIterator。
  • 具體迭代器ConcreteIterator。在ArrayList中的ListIterator迭代器實現中，指的是ListItr。

ArrayList程式碼片段

public class ArrayList<E>
{
    /**
     * 儲存新增到ArrayList中的元素。
     * ArrayList的容量就是該陣列的長度。
     * 該值為DEFAULTCAPACITY_EMPTY_ELEMENTDATA 時，當第一次新增元素進入ArrayList中時，陣列將擴容值DEFAULT_CAPACITY。
     * 被標記為transient，在物件被序列化的時候不會被序列化。
     */
    transient Object[] elementData; 

    // ArrayList的實際大小（陣列包含的元素個數）。
    private int size;

    /**
     * 返回一個一開始就指向列表索引為index的元素處的ListIterator
     *
     * @throws IndexOutOfBoundsException 
     */
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    /**
     * 返回一個一開始就指向列表索引為0的元素處的ListIterator
     * 
     * @see #listIterator(int)
     */
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    /**
     * AbstractList.ListItr的最優化版本
     */
    private class ListItr extends Itr implements ListIterator<E> {
        //用來從list中返回一個指向list索引為index的元素處的迭代器
        ListItr(int index) {
            super();
            cursor = index;
        }

        //獲取list中的上個元素
        public boolean hasPrevious() {
            return cursor != 0;
        }

        //獲取list中的下個元素的索引
        public int nextIndex() {
            return cursor;
        }

        //獲取list中的上個元素的索引
        public int previousIndex() {
            return cursor - 1;
        }

        //獲取list中的上個元素
        @SuppressWarnings("unchecked")
        public E previous() {
            checkForComodification();
            int i = cursor - 1;
            if (i < 0)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i;
            return (E) elementData[lastRet = i];
        }

        //從列表中將next()或previous()返回的最後一個元素返回的最後一個元素更改為指定元素e
        public void set(E e) {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.set(lastRet, e);
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        //將指定的元素插入列表，插入位置為迭代器當前位置之前。
        public void add(E e) {
            checkForComodification();

            try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }
}

Iterator

import java.util.function.Consumer;

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

ListItr.java

作為ArrayList的內部類。請在上文中的[ArrayList.java程式碼片段]中檢視。

總結

什麼是fail-fast？

細心地朋友看文章或原始碼時一定會發現在iterator()和listIterator()的註釋中都有一句話：返回的迭代器是fail-fast的。什麼是fail-fast？

好了，關於迭代器模式與ArrayList就寫到這裡。有什麼需要補充的歡迎在下方留言^^。

相關推薦

ArrayList與迭代器模式

本文主要講解迭代器模式在ArrayList原始碼中的使用。 迭代器模式(Iterator Pattern)：提供一種方法來訪問聚合物件中的各個元素，而不用暴露這個物件的內部表示。在Java中，ArrayList的迭代器有兩種：Iterator和ListIter

Iterator使用與迭代器設計模式

Iterator使用 迭代器（Iterator）對應與迭代器設計模式。 Iterator提供三個方法： hasNext() 判斷是否還有下一個元素 next() 獲取下一個元素 remove() 刪除元素 forEachRemaining() jdk1.8以後新增的方法，可以在動

17-Python與設計模式--迭代器模式

一、迭代器與生成器 今天的主角是迭代器模式。在python中，迭代器並不用舉太多的例子，因為python中的迭代器應用實在太多了（不管是python還是其它很多的程式語言中，實際上迭代器都已經納入到了常用的庫或者包中）。而且在當前，也幾乎沒有人專門去開發一個迭代器，而是直接去使用list、string、se

設計模式--迭代器模式與組合方法模式

迭代器模式是將對物件的遍歷封裝成迭代器，對外部隱藏物件遍歷的具體實現。 而組合方法是實現對處於不同層次的同種物件提供一致性的遍歷方法。 首先我們開始討論迭代器模式。 我們在實踐過程中可以遇到這樣的情況，我們需要對用array，ArrayList，Stack  等模式包裝的

IL角度理解for 與foreach的區別——迭代器模式

# IL角度理解for 與foreach的區別——迭代器模式 [toc] ## 1 最常用的設計模式 ### 1.1 背景 如果問你最常用的設計模式是哪種？你可能會說單例模式，工廠模式。但根據我在專案裡的經驗，一個完整的應用，應該是迭代器模式。 ### 1.2 摘要 + 本文不講怎麼去實現迭代器模

設計模式（十七）——迭代器模式（ArrayList 集合應用原始碼分析）

1 看一個具體的需求 編寫程式展示一個學校院系結構：需求是這樣，要在一個頁面中展示出學校的院系組成，一個學校有多個學院， 一個學院有多個系。如圖： 2 傳統的設計方案(類圖) 3 傳統的方式的問題分析 1) 將學院看做是學校的子類，系是學院的子類，這樣實

設計模式的藝術 行為型模式之迭代器模式

前言 現在的電視機都配置了一個遙控器，使用者可以通過遙控器去選擇上一個或者下一個臺，我們只需要知道如何使用這個遙控器，而無須關注電視是怎麼把電視訊道放入其中的，在軟體實際的開發中，也有這麼一種類，它儲存著多個成員物件，這些類通常稱為聚合類，對應的物件稱為聚合物件。為了方便操作這些聚合物件，同時可

python高階特性之迭代與迭代器

全部測試程式碼 #! /usr/bin/env python3 #_*_ conding:utf-8 _*_ 迭代：Iterable #python中使用for ... in ...來迭代物件 #python的for迴圈抽象程度高，不僅可作用在list和tuple上，還可以在任何可

常用軟體設計模式（六）迭代器模式

迭代器模式不常用，很多高階語言都將該模式封裝在語言中了，入C#的 foreach in 但是有必要了解一下 迭代器模式：提供一個方法順序訪問一個聚合物件中各個元素，而又不暴露該物件的內部表示。 優點： 1、它支援以不同的方式遍歷一個聚合物件。     &nb

重走Java設計模式——迭代器模式（Iterator Pattern）

迭代器模式 定義 提供一種方法順序訪問一個聚合物件中各個元素, 而又無須暴露該物件的內部表示。 模式結構 1.抽象容器：一般是一個介面，提供一個iterator()方法，例如java中的Collection介面，List介面，Set介面等。 2.具體

python基礎之迴圈與迭代器

迴圈  python 迴圈語句有for迴圈和while迴圈。 while迴圈while迴圈語法 while 判斷條件: 語句 #while迴圈示例 i = 0 while i < 10: i += 1; print(i) while els

設計模式 | 迭代器模式及典型應用

本文的主要內容： 介紹迭代器模式 原始碼分析迭代器模式的典型應用 Java集合中的迭代器模式 Mybatis中的迭代器模式 更多內容可訪問我的個人部落格：laijianfeng.org 關注【小旋鋒】微信公眾號，及時接收博文推送

第18章 行為型模式—迭代器模式

1. 迭代器模式（Iterator Pattern）的定義 （1）定義：提供一種方法順序訪問一個聚合物件中的各個元素，而又不需要暴露該物件的內部表示。 　　①迭代器迭代的是具體的聚合物件（如陣列和連結串列等），它圍繞的是“訪問”做文章。 　　②可用不同的遍歷策略來遍歷聚合，比如是否需要過

設計模式（十七）迭代器模式

迭代器模式(Iterator)提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露改物件的內部表示，類圖來源 https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=971311629,3818362496&fm=26&

設計模式 --- 迭代器模式

1.定義 提供一種方法順序訪問一個容器物件中的各個元素，而又不需要暴露該物件的內部表示。   2.使用場景 遍歷一個容器物件   3.簡單實現 大部分容器類都有提供迭代方法 不需要我們自己實現，這裡實現一個通用程式碼。 //迭代器介面 interf

（五）設計模式之迭代器模式（Iterator）

前言： 參考圖書：軟體設計模式與體系結構 參考部落格：https://www.cnblogs.com/wanson/articles/9277813.html   正題：         迭代器（iterator）有時又稱遊標

設計模式-迭代器模式(Iterator)

概述 定義 : 提供一種方法, 順序訪問一個集合物件中的各個元素, 而又不暴露該物件的內部表示 型別 : 行為型 適用場景 訪問一個集合物件的內容而無需暴露它的內部表示 為遍歷不同的集合結構提供一個統一的介面 優點 分離了集合物件的遍歷

迭代與迭代器

迭代 使用for迴圈遍歷取值的過程叫做迭代，比如：使用for迴圈遍歷列表獲取值的過程 for value in [2, 3, 4]: print(value) 使用for迴圈遍歷取值的物件叫做可迭代物件, 比如：列表、元組、字典、集合、range、字串 如何判斷物件

簡述-迭代器模式

介紹 一個容器，必然會涉及到遍歷演算法，如果將它封裝在容器中，則增加了複雜度，如果客戶實現，則不那麼方便。所以引入第三方類來幫忙處理，這個類就是迭代器。 又稱為遊標模式，行為型設計模式之一。我的理解是目的在遍歷，弱化容器與遍歷演算法的關係。在容器與訪問類中新增一個迭代器，用於承擔

7-迭代器模式

Array.prototype.forEach var each = function( ary, callback ){ 　　for(vari=0,l=ary.length;i<l;i++){