05容器篇（D2_集合 - D4_遍历相关）

学习须知

一、Iterable

[1. 简介](#1. 简介)

[2. 遍历方式](#2. 遍历方式)

[2.1. 用for-each循环等待的Iterable](#2.1. 用for-each循环等待的Iterable)

[2.2. 通过Iterator迭代Iterable](#2.2. 通过Iterator迭代Iterable)

[2.3. 调用Iterable的 forEach()方法迭代](#2.3. 调用Iterable的 forEach()方法迭代)

[3. Iterable接口定义](#3. Iterable接口定义)

[4. Iterable的实现](#4. Iterable的实现)

[5. 实现Iterable接口](#5. 实现Iterable接口)

[6. 获取Spliterator](#6. 获取Spliterator)

二、Iterator

[1. 简介](#1. 简介)

[2. 使用迭代器](#2. 使用迭代器)

[2.1. 获取集合的迭代器对象](#2.1. 获取集合的迭代器对象)

[2.2. 遍历集合元素](#2.2. 遍历集合元素)

[2.3. 可选操作](#2.3. 可选操作)

[3. 迭代器的优势](#3. 迭代器的优势)

[4. 迭代器的常见技巧](#4. 迭代器的常见技巧)

[4.1. 使用增强 for 循环](#4.1. 使用增强 for 循环)

[4.2. 遍历过程中的修改](#4.2. 遍历过程中的修改)

[4.3. 避免重复创建迭代器](#4.3. 避免重复创建迭代器)

[4.4. 使用迭代器的限制功能](#4.4. 使用迭代器的限制功能)

[5. 演示示例](#5. 演示示例)

[6. 知识小结](#6. 知识小结)

三、ListIterator

[1. 简介](#1. 简介)

[2. 演示示例](#2. 演示示例)

[2.1. Iterator](#2.1. Iterator)

[2.2. ListIterator](#2.2. ListIterator)

四、Enumeration

学习须知

作者：CodingW

**课程：**Iterable

**知识串联：**联系本人私聊，教大家如何知识串联！

**如何学习：**可以先加本人QQ，拉你进群哟！

**资料学习群：**JavaSE交流学习群

**QQ：**3544839383

本人其它关联专栏

数据结构篇（数组）

一、Iterable

1. 简介

Iterable接口表示一组对象，这些对象是Iterable的，这意味着可以迭代，这意味着实现Iterable接口，则可以迭代

其元素，可以通过以下方式迭代Iterable对象，使用for-each循环，从Iterable获取Iterator或者通过Iterable 的

forEach()方法，下面会一一讲解。

2. 遍历方式

2.1. 用for-each循环等待的Iterable

第一种方法就是通过for-each 循环迭代，下面例子是如何通过for-each 循环迭代List。

因为List继承了Collection 接口，Collection接口继承了Iterable ，所以List对象可以使用for-each循环：

List<String> list = new ArrayList<> ();
 
list.add("one");
list.add("two");
list.add("three");
 
for( String element : list ){
    System.out.println( element.toString() );
}

上面例子初始化了List对象，然后加了三个元素，

然后用for-each循环迭代List,并且调用toString()方法打印每个元素。

2.2. 通过Iterator迭代Iterable

第二个众方法是通过Iterator 迭代，Iterator 上一篇我们以及讲过，下面看代码：

List<String> list = new ArrayList<>();
 
list.add("one");
list.add("two");
list.add("three");
 
Iterator<String> iterator = list.iterator();
 
while(iterator.hasNext()) {
    String element = iterator.next();
    System.out.println( element );
}

2.3. 调用Iterable的 forEach()方法迭代

通过调用Iterable的 forEach()方法， forEach()方法的参数是lambda表达式，下面是代码：

List<String> list = new ArrayList<>();
 
list.add("one");
list.add("two");
list.add("three");
 
list.forEach( (element) -> {
    System.out.println( element );
});

3. Iterable接口定义

Iterable 接口中只有三个方法需要实现，另外两个以及有默认的实现，下面是 Iterable 接口的定义：

public interface Iterable<T> {
 
  Iterator<T> iterator();
 
  Spliterator<T> spliterator();
 
  void forEach(Consumer<? super T> action);
 
}

必须实现的方法是iterator()，这个方法返回一个Iterator,可以用来迭代实现了Iterable接口的对象，

获取迭代器是在底层进行的，所以看不到这一点。当将Iterable与for-each循环一起使用时，Java编译器负责为此

生成代码。

4. Iterable的实现

Iterable接口(java.lang.Iterable)是java集合根接口中的一个，因此java中有好几个类实现了Iterable接口，因此，

可以迭代这些类的内部元素。同样也有一些接口继承了Iterable接口，所以实现了继承Iterable 的接口的类，同时

也实现了Iterable 接口，这些类的元素同样可以迭代。Collection 接口继承了Iterable接口，所以所有Collection

的子类都实现了Iterable接口。比如List和Set继承了Collection接口，所以他们也继承了Iterable接口。

5. 实现Iterable接口

下面例子简单的实现了Iterable接口:

public class Persons implements Iterable {
    private List<Person> persons = new ArrayList<Person>();    
    
    public Iterator<Person> iterator() {
        return this.persons.iterator();
    }
}

Persons 实例对象可以使用for-each循环:

Persons persons = ... //obtain Persons instance with Person objects inside.
 
for(Person person : persons) {
    // do something with person object.
}

6. 获取Spliterator

可以通过 Iterable 的spliterator()方法获取Spliterator，这里不详细讲解Spliterator,只讲解一下简单的应用：

List<String> list = new ArrayList<>();
 
list.add("one");
list.add("two");
list.add("three");
 
Spliterator<String> spliterator = list.spliterator();

二、Iterator

1. 简介

在 Java 中，迭代器是一种常用的设计模式，用于遍历集合中的元素。

它提供了一种统一的方式来访问集合中的元素，而不必暴露集合的内部实现细节。

迭代器是一种对象，它允许按顺序访问集合中的元素，而不需要知道集合的底层结构。

通过使用迭代器，我们可以遍历集合并访问其中的元素，而无需关心集合的具体实现方式。

Java 提供了 Iterator 接口作为迭代器的基础接口。该接口定义了一组用于访问集合元素的方法，包括 hasNext、next 和 remove 等。

2. 使用迭代器

要使用迭代器遍历集合，我们需要进行以下步骤：

2.1. 获取集合的迭代器对象

通过调用集合的 iterator 方法获取迭代器对象。

例如，对于 ArrayList集合，可以使用 iterator()方法获取迭代器对象。

List<String> list = new ArrayList<>();
// 添加元素到集合中

Iterator<String> iterator = list.iterator();

2.2. 遍历集合元素

通过使用迭代器的 hasNext 和 next 方法来遍历集合中的元素。

hasNext 方法用于检查是否还有下一个元素，next 方法用于获取下一个元素的值。

while (iterator.hasNext()) {
    String element = iterator.next();
    // 处理元素
}

2.3. 可选操作

迭代器还提供了 remove 方法，用于从集合中删除当前迭代的元素。

需要注意的是，该方法只能在调用 next 方法后才能调用，且每次只能调用一次。

iterator.remove();

3. 迭代器的优势

使用迭代器遍历集合具有以下优势：

一、抽象集合的实现

通过使用迭代器，我们可以在不了解集合内部实现的情况下遍历和访问集合元素。

这样，集合的实现细节对外部代码是透明的。

二、安全性

迭代器提供了一种安全的方式来遍历集合。

它通过维护迭代器的状态来保证在遍历过程中不会出现并发修改的问题。

三、通用性

迭代器是一种通用的设计模式，在 Java 中被广泛应用于各种集合类型。无论是数组、列表、集合还是映射，我们

都可以使用迭代器来遍历和访问元素。

4. 迭代器的常见技巧

除了基本的使用方法外，还有一些常见的技巧可以帮助我们更好地使用迭代器。

4.1. 使用增强 for 循环

Java 提供了增强的 for 循环（foreach 循环），可以简化迭代器的使用。它可以直接遍历集合中的元素，而不需要显式地使用迭代器。

for (String element : list) {
    // 处理元素
}

4.2. 遍历过程中的修改

在使用迭代器遍历集合时，如果需要在遍历过程中修改集合，应使用迭代器的 remove 方法，而不是直接操作集

合。直接操作集合可能会导致并发修改异常。

4.3. 避免重复创建迭代器

在迭代器的使用过程中，应避免在每次迭代时都创建新的迭代器对象。

如果需要多次遍历集合，可以在第一次遍历时创建迭代器，并在后续的遍历中重复使用该迭代器。

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    // 处理元素
}

// 再次使用同一个迭代器进行遍历
while (iterator.hasNext()) {
    String element = iterator.next();
    // 处理元素
}

4.4. 使用迭代器的限制功能

迭代器提供了一些限制功能，如只读迭代器和单向迭代器。

如果在遍历过程中不需要修改集合或只需要向前遍历，可以使用只读或单向迭代器，以提高性能和安全性。

List<String> list = new ArrayList<>();
// 添加元素到集合中

Iterator<String> readOnlyIterator = list.iterator();
Iterator<String> forwardIterator = list.listIterator();

5. 演示示例

下面是一个使用迭代器遍历集合并打印元素的示例代码

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

在上面的示例中，我们创建了一个 ArrayList 集合，并使用迭代器遍历集合中的元素，然后打印每个元素的值。

6. 知识小结

迭代器是一种在 Java 中常用的设计模式，用于遍历集合中的元素。

通过使用迭代器，我们可以统一访问集合元素，而不需要了解集合的具体实现。

三、ListIterator

1. 简介

Iterator 是一种用于访问集合的方法，它不是集合。其可用来访问ArrayList、HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口，它扩展了 Iterator 接口。

Iterator 的常用方法如下：

|-------------------|-------------------------|
| 方法 | 描述 |
| boolean hasNext() | 检测集合中是否还有元素。 |
| E next() | 返回迭代器的下一个元素，并且更新迭代器的状态。 |
| void remove() | 迭代器返回的元素删除。 |

ListIterator 的常用方法如下：

|-----------------------|-------------------------|
| 方法 | 描述 |
| boolean hasNext() | 检测集合中是否还有元素。 |
| E next() | 返回迭代器的下一个元素，并且更新迭代器的状态。 |
| boolean hasPrevious() | 检测当前迭代器所在位置之前是否还有元素。 |
| E previous() | 返回迭代器的上一个元素，并且更新迭代器的状态。 |
| int nextIndex() | 返回迭代器当前位置的下一个位置索引。 |
| int previousIndex() | 返回迭代器当前位置的上一个位置索引。 |
| void remove() | 迭代器返回的元素删除。 |
| void set(E) | 设置或修改迭代器当前所在位置的元素。 |
| void add(E) | 在当前迭代器位置后添加元素。 |

2. 演示示例

2.1. Iterator

//IteratorDemo.java
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorDemo {

    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("first");
        arrayList.add("second");
        arrayList.add("third");
        arrayList.add("fourth");
        arrayList.add("fifth");

        Iterator<String> it = arrayList.iterator();
        while(it.hasNext()){
            System.out.println("打印当前迭代器位置处的元素："+it.next());
        }

    }

}


//运行结果如下：
//打印当前迭代器位置处的元素：first
//打印当前迭代器位置处的元素：second
//打印当前迭代器位置处的元素：third
//打印当前迭代器位置处的元素：fourth
//打印当前迭代器位置处的元素：fifth

//Process finished with exit code 0
//IteratorDemo.java
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorDemo {

    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("first");
        arrayList.add("second");
        arrayList.add("third");
        arrayList.add("fourth");
        arrayList.add("fifth");

        Iterator<String> it = arrayList.iterator();
        while(it.hasNext()){
            String removeEle = it.next();
            if("fourth".equals(removeEle)){
                it.remove();
            }
        }
        System.out.println("删除fourth这个元素后，arrayList的内容为："+arrayList);

    }

}

//运行结果如下：
//删除fourth这个元素后，arrayList的内容为：[first, second, third, fifth]

//Process finished with exit code 0

2.2. ListIterator

package com.example.utils.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ListIteratorDemo {

    public static void main(String[] args) {

        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("first");
        arrayList.add("second");
        arrayList.add("third");
        arrayList.add("fourth");
        arrayList.add("fifth");

        ListIterator<String> it = arrayList.listIterator();
        while(it.hasNext()){
            String removeEle = it.next();
            if("fourth".equals(removeEle)){
                it.set("updated fourth");
                it.add("sixth");
            }
        }
        System.out.println("执行上述操作后，arrayList的内容为："+arrayList);

    }

}

//执行结果如下：
//执行上述操作后，arrayList的内容为：[first, second, third, updated fourth, sixth, fifth]

//Process finished with exit code 0

四、Enumeration

Enumeration中提供了hasMoreElements()方法和nextElement()方法

前者方法用来检查数据结构中下一个元素是否存在

后者方法在下一个元素存在时用来返回下一个元素

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class EnumerationTest {
    public static void main(String[] args) {
        Enumeration<String> enumeration;
        Vector<String> vector=new Vector<>();
        vector.add("lkj");
        vector.add("ppp");
        enumeration=vector.elements();
        while (enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
    }
}