Java 集合迭代器

原文： https://javabeginnerstutorial.com/core-java-tutorial/java-collection-iterators/

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

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

关于迭代器

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

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

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

  1. package java.util;
  3. import java.util.function.Consumer;
  5. public interface Iterator {
  7.     boolean hasNext();
  9.     E next();
  11.     default void remove() {
  12.         throw new UnsupportedOperationException("remove");
  13.     }
  15.     default void forEachRemaining(Consumer<? super E> action) {
  16.         Objects.requireNonNull(action);
  17.         while (hasNext())
  18.             action.accept(next());
  19.     }
  20. }

该接口支持 4 种操作：

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

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

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

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

示例

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

迭代

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

  1.  Iterator
  2.                 iterator = Arrays.asList("HEARTS", "SPADES", "CLUBS", "DIAMONDS").iterator();
  3.         while (iterator.hasNext()) {
  4.             System.out.println(iterator.next());
  5.         }

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

  1. HEARTSSPADESCLUBSDIAMONDS

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

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

结果是：

  1. HEARTS 2SPADES 3CLUBS 4DIAMONDS 5

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

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

结果是

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

这不是您想要的。

在循环后使用迭代器

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

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

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

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

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

使用for循环

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

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

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

  1. 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接口：

  1. 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。 因此，如果您尝试删除元素，则会出现异常。

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

  1. 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();    }}
  2. System.out.println(numbers);

此代码导致以下结果：

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

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

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

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

forEachRemaining

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

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

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

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

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

结果是：

  1. 562388346784533

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

  1. 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接口，以为以后处理不同集合实现的文章奠定基础。