1. 程式人生 > >Java 迭代介面:Iterator、ListIterator 和 Spliterator

Java 迭代介面:Iterator、ListIterator 和 Spliterator

1. 簡介

當我們使用 forwhile 迴圈來遍歷一個集合的元素,Iterator 允許我們不用擔心索引位置,甚至讓我們不僅僅是遍歷一個集合,同時還可以改變它。例如,你如果要刪除迴圈中的元素,那麼 for 迴圈不見得總是可行的。

結合自定義的迭代器,我們可以迭代更為複雜的物件,以及向前和向後移動,並且知曉如何利用其優勢也將變得非常清楚。

本文將深入討論如何使用 IteratorIterable 介面。

2. Iterator()

Iterator 介面用於迭代集合中的元素(ListSetMap)。它用於逐個檢索元素,並在需要時針對每個元素執行操作。

下面是用於遍歷集合與執行操作的方法:

  • .hasNext():如果還沒有到達集合的末尾,則返回 true,否則返回 false
  • .next():返回集合中的下一個元素
  • .remove():從集合中移除迭代器返回的最後一個元素
  • .forEachRemaining():按順序為集合中剩下的每個元素執行給定的操作

首先,由於迭代器是用於集合的,讓我們做一個簡單的包含幾個元素的 ArrayList

List<String> avengers = new ArrayList<>();

// Now lets add some Avengers to the list
avengers.add("Ant-Man");
avengers.add("Black Widow");
avengers.add("Captain America");
avengers.add("Doctor Strange");

我們可以使用一個簡單迴圈來遍歷這個集合:

System.out.println("Simple loop example:\n");
for (int i = 0; i < avengers.size(); i++) {
    System.out.println(avengers.get(i));
}

不過,我們想探索迭代器:

System.out.println("\nIterator Example:\n");

// First we make an Iterator by calling 
// the .iterator() method on the collection
Iterator<String> avengersIterator = avengers.iterator();

// And now we use .hasNext() and .next() to go through it
while (avengersIterator.hasNext()) {
    System.out.println(avengersIterator.next());
}

如果我們想從這個 ArrayList 中刪除一個元素,會發生什麼?讓我們試著使用常規的 for 迴圈:

System.out.println("Simple loop example:\n");
for (int i = 0; i < avengers.size(); i++) {
    if (avengers.get(i).equals("Doctor Strange")) {
        avengers.remove(i);
    }
    System.out.println(avengers.get(i));
}

我們會收到一個討厭的 IndexOutOfBoundsException

Simple loop example:

Ant-Man
Black Widow
Captain America
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 3, Size: 3

這在遍歷集合時更改其大小是有意義的,增強 for 迴圈也一樣:

System.out.println("Simple loop example:\n");
for (String avenger : avengers) {
    if (avenger.equals("Doctor Strange")) {
        avengers.remove(avenger);
    }
    System.out.println(avenger);
}

我們再次收到了另一個異常:

Simple loop example:

Ant-Man
Black Widow
Captain America
Doctor Strange
Exception in thread "main" java.util.ConcurrentModificationException

這時迭代器就派上用場了,由它充當中間人,從集合中刪除元素,同時確保遍歷按計劃繼續:

Iterator<String> avengersIterator = avengers.iterator();
while (avengersIterator.hasNext()) {
    String avenger = avengersIterator.next();

    // First we must find the element we wish to remove
    if (avenger.equals("Ant-Man")) {
        // This will remove "Ant-Man" from the original
        // collection, in this case a List
        avengersIterator.remove();
    }
}

這是保證在遍歷集合時刪除元素的安全方法。

並確認該元素是否已被刪除:

// We can also use the helper method .forEachRemaining()
System.out.println("For Each Remaining Example:\n");
Iterator<String> avengersIteratorForEach = avengers.iterator();

// This will apply System.out::println to all elements in the collection
avengersIteratorForEach.forEachRemaining(System.out::println);

輸出如下:

For Each Remaining Example:

Black Widow
Captain America
Doctor Strange

正如你所看到的,蟻人已經從 復仇者聯盟 的名單中刪除了。

2.1. ListIterator()

ListIterator 繼承自 Iterator 介面。它只在 List 上進行使用,可以雙向迭代,這意味著你可以從前到後或從後到前進行迭代。它也沒有 current 元素,因為遊標總是放在 List 的兩個元素之間,所以我們用 .previous().next() 來訪問元素。

IteratorListIterator 之間有什麼區別呢?

首先,Iterator 可以用於 任意集合 —— ListMapQueueSet 等。

ListIterator 只能應用於 List,通過新增這個限制,ListIterator 在方法方面可以更加具體,因此,我們引入了許多新方法,他們可以幫助我們在遍歷時對其進行修改。

如果你正在處理 List 實現(ArrayListLinkedList等),那麼使用 ListIterator 更為可取一些。

下面是你可能會用到的方法:

  • .add(E e):向 List 中新增元素。
  • .remove():從 List 中刪除 .next().previous() 返回的最後一個元素。
  • .set(E e):使用指定元素來覆蓋 List .next().previous() 返回的最後一個元素。
  • .hasNext():如果還沒有到達 List 的末尾,則返回 true,否則返回 false
  • .next():返回 List 中的下一個元素。
  • .nextIndex():返回下一元素的下標。
  • .hasPrevious():如果還沒有到達 List 的開頭,則返回 true,否則返回 false
  • .previous():返回 List 的上一個元素。
  • .previousIndex():返回上一元素的下標。

再次,讓我們用一些元素構成一個 ArrayList

ArrayList<String> defenders = new ArrayList<>();

defenders.add("Daredevil");
defenders.add("Luke Cage");
defenders.add("Jessica Jones");
defenders.add("Iron Fist");

讓我們用 ListIterator 來遍歷 List 並列印其元素:

ListIterator listIterator = defenders.listIterator(); 
  
System.out.println("Original contents of our List:\n");
while (listIterator.hasNext()) 
    System.out.print(listIterator.next() + System.lineSeparator()); 

顯然,它的工作方式與 Iterator 相同。輸出如下:

Original contents of our List: 

Daredevil
Luke Cage
Jessica Jones
Iron Fist

現在,讓我們來嘗試修改一些元素:

System.out.println("Modified contents of our List:\n");

// Now let's make a ListIterator and modify the elements
ListIterator defendersListIterator = defenders.listIterator();

while (defendersListIterator.hasNext()) {
    Object element = defendersListIterator.next();
    defendersListIterator.set("The Mighty Defender: " + element);
}

現在列印 List 的話會得到如下結果:

Modified contents of our List:

The Mighty Defender: Daredevil
The Mighty Defender: Luke Cage
The Mighty Defender: Jessica Jones
The Mighty Defender: Iron Fist

現在,讓我們倒著遍歷列表,就像我們可以用 ListIterator 做的那樣:

System.out.println("Modified List backwards:\n");
while (defendersListIterator.hasPrevious()) {
    System.out.println(defendersListIterator.previous());
}

輸出如下:

Modified List backwards:

The Mighty Defender: Iron Fist
The Mighty Defender: Jessica Jones
The Mighty Defender: Luke Cage
The Mighty Defender: Daredevil

3. Spliterator()

Spliterator 介面在功能上與 Iterator 相同。你可能永遠不需要直接使用 Spliterator,但讓我們繼續討論一些用例。

但是,你應首先熟悉 Java Streams 和 Lambda Expressions in Java。

雖然我們將列出 Spliterator 擁有的所有方法,但是 Spliterator 介面的全部工作超出了本文的範疇。我們將通過一個例子討論 Spliterator 如何使用並行化更有效地遍歷我們可以分解的 Stream

我們在處理 Spliterator 時使用的方法是:

  • .characteristics()

    : 返回該 Spliterator 具有的作為

    int

    值的特徵。 這些包括:

    • ORDERED
    • DISTINCT
    • SORTED
    • SIZED
    • CONCURRENT
    • IMMUTABLE
    • NONNULL
    • SUBSIZED
  • .estimateSize():返回遍歷作為 long 值遇到的元素數量的估計值,如果無法返回則返回 long.MAX_VALUE

  • .forEachRemaining(E e):按順序對集合中的每個剩餘元素執行給定操作。

  • .getComparator():如果該 Spliterator 的源是由 Comparator 排序的,其將返回 Comparator

  • .getExactSizeIfKnown():如果大小已知則返回 .estimateSize(),否則返回 -1

  • .hasCharacteristics(int characteristics):如果這個 Spliterator.characteristics() 包含所有給定的特徵,則返回 true

  • .tryAdvance(E e):如果存在剩餘元素,則對其執行給定操作,返回 true,否則返回 false

  • .trySplit():如果這個 Spliterator 可以被分割槽,返回一個 Spliterator 覆蓋元素,當從這個方法返回時,它將不被這個 Spliterator 覆蓋。

像往常一樣,讓我們從一個簡單的 ArrayList 開始:

List<String> mutants = new ArrayList<>();

mutants.add("Professor X");
mutants.add("Magneto");
mutants.add("Storm");
mutants.add("Jean Grey");
mutants.add("Wolverine");
mutants.add("Mystique");

現在,我們需要將 Spliterator 應用於 Stream。值得慶幸的是,由於 Collections 框架,很容易在 ArrayListStream 之間進行轉換:

// Obtain a Stream to the mutants List.
Stream<String> mutantStream = mutants.stream();

// Getting Spliterator object on mutantStream.
Spliterator<String> mutantList = mutantStream.spliterator();

為了展示其中的一些方法,讓我們分別執行下它們:

// .estimateSize() method
System.out.println("Estimate size: " + mutantList.estimateSize());

// .getExactSizeIfKnown() method
System.out.println("\nExact size: " + mutantList.getExactSizeIfKnown());

System.out.println("\nContent of List:");
// .forEachRemaining() method
mutantList.forEachRemaining((n) -> System.out.println(n));

// Obtaining another Stream to the mutant List.
Spliterator<String> splitList1 = mutantStream.spliterator();

// .trySplit() method
Spliterator<String> splitList2 = splitList1.trySplit();

// If splitList1 could be split, use splitList2 first.
if (splitList2 != null) {
    System.out.println("\nOutput from splitList2:");
    splitList2.forEachRemaining((n) -> System.out.println(n));
}

// Now, use the splitList1
System.out.println("\nOutput from splitList1:");
splitList1.forEachRemaining((n) -> System.out.println(n));

我們將得到輸出:

Estimate size: 6

Exact size: 6

Content of List: 
Professor X
Magneto
Storm
Jean Grey
Wolverine
Mystique

Output from splitList2: 
Professor X
Magneto
Storm

Output from splitList1: 
Jean Grey
Wolverine
Mystique

4. Iterable()

如果出於某種原因,我們想要建立一個自定義的 Iterator 介面,應該怎麼辦?你首先要熟悉的是這張圖:

要建立自定義 Iterator,我們需要為 .hasNext().next().remove() 做自定義實現。

Iterator 介面中,有一個方法,它返回一個集合中元素的迭代器,即 .iterator() 方法,還有一個方法為迭代器中的每個元素執行一個操作的方法,即 .dorEach() 方法。

例如,假設我們是 Tony Stark,我們需要寫個自定義迭代器來列出當前武器庫中的每件鋼鐵俠套裝。

首先,讓我們建立一個類來獲取和設定 suit 資料:

public class Suit {

    private String codename;
    private int mark;

    public Suit(String codename, int mark) {
        this.codename = codename;
        this.mark = mark;
    }

    public String getCodename() { return codename; }

    public int getMark() { return mark; }

    public void setCodename (String codename) {this.codename=codename;}

    public void setMark (int mark) {this.mark=mark;}

    public String toString() {
        return "mark: " + mark + ", codename: " + codename;
    }
}

接下來讓我們編寫自定義 Iterator:

// Our custom Iterator must implement the Iterable interface
public class Armoury implements Iterable<Suit> {
    
    // Notice that we are using our own class as a data type
    private List<Suit> list = null;

    public Armoury() {
        // Fill the List with data
        list = new LinkedList<Suit>();
        list.add(new Suit("HOTROD", 22));
        list.add(new Suit("SILVER CENTURION", 33));
        list.add(new Suit("SOUTHPAW", 34));
        list.add(new Suit("HULKBUSTER 2.0", 48));
    }
    
    public Iterator<Suit> iterator() {
        return new CustomIterator<Suit>(list);
    }

    // Here we are writing our custom Iterator
    // Notice the generic class E since we do not need to specify an exact class
    public class CustomIterator<E> implements Iterator<E> {
    
        // We need an index to know if we have reached the end of the collection
        int indexPosition = 0;
        
        // We will iterate through the collection as a List
        List<E> internalList;
        public CustomIterator(List<E> internalList) {
            this.internalList = internalList;
        }

        // Since java indexes elements from 0, we need to check against indexPosition +1
        // to see if we have reached the end of the collection
        public boolean hasNext() {
            if (internalList.size() >= indexPosition +1) {
                return true;
            }
            return false;
        }

        // This is our custom .next() method
        public E next() {
            E val = internalList.get(indexPosition);

            // If for example, we were to put here "indexPosition +=2" we would skip every 
            // second element in a collection. This is a simple example but we could
            // write very complex code here to filter precisely which elements are
            // returned. 
            // Something which would be much more tedious to do with a for or while loop
            indexPosition += 1;
            return val;
        }
        // In this example we do not need a .remove() method, but it can also be 
        // written if required
    }
}

最後是 main 方法類:

public class IronMan {

    public static void main(String[] args) {

        Armoury armoury = new Armoury();

        // Instead of manually writing .hasNext() and .next() methods to iterate through 
        // our collection we can simply use the advanced forloop
        for (Suit s : armoury) {
            System.out.println(s);
        }
    }
}

輸出如下:

mark: 22, codename: HOTROD
mark: 33, codename: SILVER CENTURION
mark: 34, codename: SOUTHPAW
mark: 48, codename: HULKBUSTER 2.0

5. 總結

本文中,我們詳細討論瞭如何使用 Java 中的迭代器,甚至寫了一個定製的迭代器來探索 Iterable 介面的所有新的可能性。

我們還討論了 Java 是如何利用 Stream 的並行化,使用 Spliterator 介面對集合的遍歷進行內部優化。


8月福利準時來襲,關注公眾號

後臺回覆:003即可領取7月翻譯集錦哦~

往期福利回覆:001,002即可領取!

相關推薦

Java 介面IteratorListIterator Spliterator

1. 簡介 當我們使用 for 或 while 迴圈來遍歷一個集合的元素,Iterator 允許我們不用擔心索引位置,甚至讓我們不僅僅是遍歷一個集合,同時還可以改變它。例如,你如果要刪除迴圈中的元素,那麼 for 迴圈不見得總是可行的。 結合自定義的迭代器,我們可以迭代更為複雜的物件,以及向前和向後移動,並且

Javaiteratoriterable介面的區別

首先,需要強調的是iterator 和 iterable 都是介面,並不是像某些不負責任的文章講的那樣:iterator是介面iterable的實現類。實際情況是,它們兩個都是介面。 如果它們兩個都是介面,那為什麼要有兩個介面?它們的區別在哪裡? 推薦一篇文章,寫的不錯,http://blo

訪問string物件vector物件

我們都知道可以用下標運算來訪問string物件和vector物件。而另外還有一種更通用的方法也可以實現這樣的方法。名曰:迭代器(iterator)。 類似於指標,迭代器也提供了對物件的間接訪問。就迭代器而言,其物件是容器中的元素或者string中的字元。使

java-Collection集合List集合Vector集合IteratorListIterator的使用

1、物件陣列的概述和使用  * A:案例演示     * 需求:我有5個學生,請把這個5個學生的資訊儲存到陣列中,並遍歷陣列,獲取得到每一個學生資訊。    *     Student[] arr = new Student[5]; //儲存學生物件     arr[0] = new Student("張三

java——IteratorIterablefor迴圈

Iterable介面 (java.lang.Iterable) 是Java集合的頂級介面之一,Iterable介面中只包含一個方法,就是iterator()方法,用來返回一個Iterator型別的物件,或者說返回一個實現了Iterator介面的物件。實現了Ite

java設計模式——器模式(Iterator Pattern)

概述:          在軟體開發中,我們經常需要使用聚合物件來儲存一系列資料。聚合物件擁有兩個職責:一是儲存資料;二是遍歷資料。從依賴性來看,前者是聚合物件的基本職責;而後者既是可變化的,又是可分離的。因此,可以將遍歷資料

Python中的容器(container)器(iterator生成器(generator:yield)

1、容器迭代器iterator  以list容器(tuple,range,file類似)為例,list容器可以呼叫自己的__iter__()方法獲取用來迭代自己內部元素的迭代器。例如: # list容器 myList = [1, 2, 3] # 獲取list容器的迭代器 it

Java碼復用的三種常用方式繼承組合代理

是個 繼續 不想 完成 extend 工作 代碼復用 輕松 例如 復用代碼是Java眾多引人註目的功能之一。這句話很通順,沒什麽問題,但問題在於很多人並不清楚“復用”是什麽。就好像我說“沈默王二是一個不止會寫代碼的程序員”,唉,沈默王二是誰? 我們需要來給“復用”下一個定義

淺談Java設計模式——器模式(Iterator)

一、概述         給定一個語言,定義它的文法的一種表示,並定義一個直譯器,這個直譯器使用該表示來解釋語言中的句子。 二、使用場景 1.訪問一個聚合物件的內容而無需暴露它的內部表示。  2.支援對聚合物件的多種遍歷。  3.為遍歷不同的聚合結構提供一個統一的介

java iterator的原理 淺談

迭代器是工作在一個獨立的執行緒中,並且擁有一個mutex鎖,就是說iterator在工作的時候,是不允許被迭代的物件被改變的。iterator被建立的時候建立一個記憶體索引表(單鏈表),這個索引表指向原來的物件,當原來的物件數量改變的時候,這個索引表的內容沒有同步改變,所以

設計模式(十)從電影院中認識"器模式"(Iterator Pattern)

上篇部落格我們從醋溜土豆絲與清炒苦瓜中認識了“”,那麼在今天這篇部落格中我們要從電影院中來認識"迭代器模式"(Iterator Pattern)。“迭代器模式”顧名思義就是通過迭代的形式來取出容器中的值。如果你對Java語言熟悉的話,那麼你應該使用過Java中的迭代器,迭代器一般使用hasNext()方法來判

c++設計模式器模式(Iterator Pattern)

定義:迭代器模式提供一種方法順序訪問一個聚合物件中的各個元素,而又不暴露其內部的表示。 場景:我們有兩個聚合A和B,有一個聚合管理的類,包含聚合A和B,而這個管理類的功能就是依次遍歷它所包含的聚合中的元素並列印到控制檯上。每個聚合中的元素存放的方式是不同的,有的用的是陣

Go語言設計模式實踐器(Iterator

關於本系列 決定開個新坑。 這個系列首先是關於Go語言實踐的。在專案中實際使用Go語言也有段時間了,一個體會就是不論是官方文件、圖書還是網路資料,關於Go語言慣用法(idiom)的介紹都比較少,基本只能靠看標準庫原始碼自己琢磨,所以我特別想在這方面有一些收集和總結。 然後這個系列也是關於設計模式的。雖然G

Java器(轉)(iterator詳解以及for迴圈的區別)

迭代器是一種模式,它可以使得對於序列型別的資料結構的遍歷行為與被遍歷的物件分離,即我們無需關心該序列的底層結構是什麼樣子的。只要拿到這個物件,使用迭代器就可以遍歷這個物件的內部.1.IteratorJava提供一個專門的迭代器«interface»Iterator,我們可以對某個序列實現該interface,

Java器(iterator詳解以及for迴圈的區別)

前言:        迭代器是一種模式、詳細可見其設計模式,可以使得序列型別的資料結構的遍歷行為與被遍歷的物件分離,即我們無需關心該序列的底層結構是什麼樣子的。只要拿到這個物件,使用迭代器就可以遍歷這個物件的內部。Iterable:實現這個介面的集合物件支援迭代,是可以迭代的

java各種List迴圈forforEachlambda forEachstream forEachiterator效能效率對比

橫向縱向測試程式碼:for( int t=1;t<5;t++){ for(int tt=1;tt<=4;tt++){ List<Integer> testList = Arrays.asList(new Integer[(int

Java多線程編程CallableFutureFutureTask淺析

創建線程 執行 過程 data- body javase 接下來 而後 定義 通過前面幾篇的學習,我們知道創建線程的方式有兩種,一種是實現Runnable接口,另一種是繼承Thread,但是這兩種方式都有個缺點,那就是在任務執行完成之後無法獲取返回結果,那如果我們想要獲取返

Java並發編程CallableFutureFutureTask

done 泛型 new row run new t com 取消 底層 在前面的文章中我們講述了創建線程的2種方式,一種是直接繼承Thread,另外一種就是實現Runnable接口。這2種方式都有一個缺陷就是:在執行完任務之後無法獲取執行結果。如果需要獲取執行結果,就必須通

玩玩微信公眾號Java版之二接收處理及返回微信消息

log med iou set arch weixin b- rom data- 前面已經配置了微信服務器,那麽先開始最簡單的接收微信消息吧~ 可以用我們的微信號來直接進行測試,下面先看測試效果圖: 這是最基本的文本消息的接收、處理及返回,來看看是怎麽實現的