# Java 集合迭代器

> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-collection-iterators/](https://javabeginnerstutorial.com/core-java-tutorial/java-collection-iterators/)

在本文中，我们将开始一个新系列，我们将深入研究 1.8 版中可用的 Java 不同的收集解决方案。 对于具体的实现（例如`ArrayList`或`TreeSet`），我们将为您提供一些用例，这些用例将在这些用例中脱颖而出，并在某些情况下您应使用不同的用例。 当然，我们将写关于 Java 8 引入的流利 API 的信息。

在本文中，我们将从`Iterator`接口开始，它是 Java 中所有集合导航的基础。

## 关于迭代器

当您要处理各种集合时，迭代器是基本概念。 顾名思义，它用于遍历集合的元素。

此接口在 Java 的版本 **1.2** 中引入。 在此之前，您可以使用`Enumeration`接口-该接口仍然存在，但建议您使用基于`Iterator`接口的集合。

如果我们看一下接口定义，它非常苗条：

```java
package java.util;

import java.util.function.Consumer;

public interface Iterator {

    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());
    }
} 
```

该界面支持 4 种操作：

*   `hasNext`：如果当前可迭代对象具有更多要访问的元素，则此方法返回`true`。
*   `next`：此方法返回当前可迭代对象中的下一个对象。 如果没有更多对象，则将获得`java.util.NoSuchElementException`。
*   `remove`：此方法用于从给定的可迭代对象中删除元素。 如您所见，这是默认方法。 这意味着，并非`Iterator`接口的每个实现都必须实现此方法。 而且，如果未实现，则会得到一个`java.lang.UnsupportedOperationException`。
*   `forEachRemaining`：此方法在此可迭代过程中的每个剩余元素上调用提供的操作-或直到该操作引发异常。

如您所见，此接口具有正确数量的方法，可让您开始进行迭代。 您唯一不能做的就是将元素添加到可迭代对象中。 但是我们可以忍受。

正如您已经在思考的那样，唯一的限制是只能进行*正向迭代*。

在本系列的后面部分，我们将看一下`ListIterator`，它扩展了`Iterator`，是专门处理列表遍历的专家，并添加了一些有用的方法。

## 例子

现在是时候使用`Iterator`界面进行一些示例了。 因为我们没有引入其他任何集合，所以我们使用由`java.util.Arrays.asList`创建的列表。

## 反复进行

这是非常基本的用例：迭代：

```java
 Iterator
                iterator = Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS").iterator();
         while (iterator.hasNext()) { 
            System.out.println(iterator.next()); 
        } 
```

如您所料，这将导致以下结果：

```java
HEARTS SPADES CLUBS DIAMONDS 
```

即使迭代很容易，也有一些陷阱：

```java
 Iterator suits = Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS").iterator(); 
        Iterator ranks = Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A").iterator(); 
        while (ranks.hasNext()) { while (suits.hasNext()) { System.out.println(suits.next() + " " + ranks.next()); } } 
```

结果是：

```java
HEARTS 2 SPADES 3 CLUBS 4 DIAMONDS 5 
```

这有一个小错误，但是如果我们切换迭代器的执行顺序，则会出现错误：

```java
 Iterator suits = Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS").iterator(); 
        Iterator ranks = Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A").iterator(); 
        while (suits.hasNext()) { while (ranks.hasNext()) { System.out.println(suits.next() + " " + ranks.next()); } } 
```

结果是

```java
HEARTS 2 SPADES 3 CLUBS 4 DIAMONDS 5 Exception in thread "main" java.util.NoSuchElementException     at java.util.AbstractList$Itr.next(AbstractList.java:364)
```

这不是您想要的。

## 循环后使用迭代器

开发人员在开始时遇到的一个常见问题是，他们在循环之后访问迭代器：

```java
 Iterator iterator = Arrays.asList(1, 4, 223, 56, 23, 88, 346, 78, 45, 33).iterator(); 
        while (iterator.hasNext()) { iterator.next(); } iterator.next(); 
```

结果取决于 Iterator 在不同异常中的实现，但是如果实现遵循接口的约定，则会得到 java.util.NoSuchElementException：

```java
Exception in thread "main" java.util.NoSuchElementException     at java.util.AbstractList$Itr.next(AbstractList.java:364) 
```

这意味着，您只能将一个迭代器导航到末尾。

## 使用`for`循环

解决上述问题的方法是使用`for`循环。 除了解决上述问题之外，它还使您的代码更清晰，更易读。 并且避免在循环后使用迭代器导致异常：

```java
 for (Iterator ranks = Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A").iterator(); ranks.hasNext(); ) { 
            String rank = ranks.next(); 
            for (Iterator suits = Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS").iterator(); suits.hasNext(); ) { 
                String suit = suits.next(); System.out.println(suit + " " + rank); } } 
```

另外，您可以利用增强的`for`循环使您的解决方案更具可读性：

```java
for (String rank : Arrays.asList("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A")) {     for (String suit : Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS")) {         System.out.println(suit + " " + rank);     } } 
```

而且，作为一个很好的副作用，我们甚至不需要了解`Iterator`接口的工作原理，它全都封装在 Java 运行时的精巧手下。

### 移除元素

另一个常见的问题是在使用集合删除元素时。 不会导致错误或复制列表的最可行解决方案是使用`Iterator`接口：

```java
List numbers = new ArrayList<>(Arrays.asList(1, 4, 223, 56, 23, 88, 346, 78, 45, 33)); Iterator iterator = numbers.iterator(); while (iterator.hasNext()) {     if (iterator.next() > 100) {         iterator.remove();     } } 
```

上面的这段代码从列表中删除了所有大于 100 的元素。如您所见，这里我们需要将列表的整个创建包装到一个显式的`ArrayList`构造器中。 这是因为`java.util.Arrays`是如何工作的：它返回一个不支持修改的特殊`ArrayList`。 因此，如果您尝试删除元素，则会出现异常。

同样，请注意如何使用迭代器！

```java
List numbers = new ArrayList<>(Arrays.asList(1, 4, 223, 56, 23, 88, 346, 78, 45, 33)); Iterator iterator = numbers.iterator(); while (iterator.hasNext()) {     if (iterator.next() < 0 || iterator.next() > 100) {         iterator.remove();     } } 
System.out.println(numbers); 
```

此代码导致以下结果：

```java
[1, 4, 223, 56, 23, 88, 346, 78, 45, 33] 
```

如您所见，元素未更改。 为什么？ 因为`if`条件在条件的两边都调用`iterator.next()`，在这种情况下，我们跳过了大的值。

如果列表中包含奇数个元素，我们将获得异常而不是意外的结果。

我们将在后面的文章中看到，有一种更好和更易读的方式从集合中删除元素。

### `forEachRemaining`

`forEachRemaining`方法是 Java 8 中的新增功能。它获取`java.util.function.Consumer`作为参数，该参数将为迭代器的每个其余元素调用。

目前，我看不到任何可以从这种新方法中受益的用例，但是应该有 Java 开发人员将其添加到组合中。

无论如何，想像一下，您要打印迭代器的所有元素，这些元素在大于 100 的第一个元素之后。您可以这样进行：

也有一些不同的解决方案，但它们涉及自定义逻辑。 但是，使用这种新方法，您可以像下面这样解决它：

```java
Iterator iterator = Arrays.asList(1, 4, 223, 56, 23, 88, 346, 78, 45, 33).iterator();  while (iterator.hasNext()) {     if (iterator.next() > 100) {         break;     } }
iterator.forEachRemaining(System.out::println); 
```

结果是：

```java
56 23 88 346 78 45 33
```

而且，如果迭代器结束了，并且没有增加目标的任何元素，那么它也不会引发异常：

```java
Iterator iterator = Arrays.asList(1, 4, 223, 56, 23, 88, 346, 78, 45, 33).iterator();  while (iterator.hasNext()) {     if (iterator.next() > 500) {         break;     } } iterator.forEachRemaining(System.out::println); 
```

## 结论

如果您有一个元素集合并且想要浏览它们 – 并从该集合中删除元素，则`Iterator`接口是基本的解决方案。

这里的方法是有限的：您不能向该集合中添加元素，也不能向后导航...并且使用 Java **1.5** ，引入了新的集合接口，这使我们的开发人员的生活更加轻松。

在下一篇文章中，我们将研究`java.util.Collection`和`java.util.Iterable`接口，以为以后处理不同集合实现的文章奠定基础。