使用嵌套迭代器迭代两级结构

Question

我有以下两级XML 结构。一个盒子列表，每个盒子都包含一个抽屉列表。

<Boxes>
    <Box id="0">
        <Drawers>
            <Drawer id="0"/>
            <Drawer id="1"/>
            ...
        </Drawers>
    </Box>
    <Box id="1">
...
    </Box>
</Boxes>

我正在使用StAX 解析它并通过两个Iterators 暴露结构：

1. BoxIterator implements Iterator<Box>, Iterable<Box>
2. Box implements Iterable<Drawer>
3. DrawerIterator implements Iterator<Drawer>

然后我可以执行以下操作：

BoxIterator boxList;
for (Box box : boxList) {
  for (Drawer drawer : box) {
    drawer.getId()
  }
}

在Iterators 的底层，我使用的是StAX，它们都在访问相同的底层XMLStreamReader。如果我调用BoxIterator.next()，它将影响后续调用DrawerIterator.next() 时返回的结果，因为光标将移动到下一个框。

这会破坏Iterator 的合同吗？ 有没有更好的方法来使用StAX 迭代两级结构？

Answer 1

您的代码的唯一设计问题是BoxIterator 实现了Iterator 和Iterable。通常，每次调用 iterator() 方法时，Iterable 对象都会返回新的有状态 Iterator。因此，两个迭代器之间应该没有干扰，但是您需要一个状态对象来正确实现从内部循环退出（可能您已经拥有它，但为了清楚起见，我必须提到它）。

1. State 对象将充当解析器的代理，具有两个方法 popEvent 和 peekEvent。偷看迭代器将检查最后一个事件，但不会消耗它。在弹出时，他们将消费最后一个事件。
2. BoxIterable#iterator() 将消耗 StartElement(Boxes) 并在此之后返回迭代器。
3. BoxIterator#hasNext() 将查看事件并弹出它们，直到收到 StartElement 或 EndElement。只有在收到 StartElement(Box) 时才会返回 true。
4. BoxIterator#next() 将 peek-and-pop 属性事件，直到收到 StartElement 或 EndElement 来初始化 Box 对象。
5. Box#iterator() 将消费 StartElement(Drawers) 事件，然后返回 DrawerIterator。
6. DrawerIterator#hasNext() 将在收到 StartElement 或 EndElement 之前进行偷看。只有当它是 StartElement(Drawer) 时才会返回 true
7. DrawerIterator#next() 将使用 Attribute 事件，直到收到 EndElement(Drawer)。

您的用户代码几乎不会被修改：

BoxIterable boxList;
/*
 * boxList must be an BoxIterable, which on call to iterator() returns 
 * new BoxIterator initialized with current state of STaX parser
 */
for (Box box : boxList) { 
  /* 
   * on following line new iterator is created and initialized 
   * with current state of parser 
   */
  for (Drawer drawer : box) { 
    drawer.getId()
  }
}

Answer 2

如果您通过实现Iterator 接口仔细实现/覆盖BoxIterator 和DrawerIterator 中的next() 和hasNext() 方法，它看起来不会违反合同。不用说，要注意的明显条件是，如果 next() 返回一个元素，hasNext() 应该返回 true，如果 next() 给出异常，则 false 应该返回。

但我无法理解的是你为什么让BoxIterator实现Iterable<Box>

BoxIterator implements Iterator<Box>, Iterable<Box> 由于从Iterable 接口为Box 覆盖iterator() 方法总是会返回BoxIterator 的实例。如果你背后没有任何其他目的，那么在BoxIterator中封装这个特性是没有目的的。

Answer 3

这会违反Iterator的合同吗？

没有。

Java Iterator 强加了两个“合同”。第一个合约是 Java 接口本身，它声明了 3 个方法：hasNext()、next() 和 remove()。任何实现此Iterator 接口的类都必须定义这些方法。

第二个合约定义了Iterator的行为：

hasNext() [...] 如果迭代有更多元素，则返回 true。 [...] next() 返回迭代中的下一个元素 [并且] 如果迭代没有更多元素，则抛出 NoSuchElementException。

这就是整个合同。

确实，如果底层XMLStreamReader 是高级的，它可能会弄乱你的BoxIterator 和/或DrawerIterator。或者，在错误的位置调用BoxIterator.next() 和/或DrawerIterator.next() 可能会打乱迭代。但是，正确使用，例如在上面的示例代码中，它可以正常工作并大大简化了代码。您只需要记录迭代器的正确用法即可。

作为一个具体的例子，Scanner 类实现了Iterator<String>，但还有许多其他方法可以推进底层流。如果存在由Iterator 类强加的更强大的契约，那么Scanner 类本身就会违反它。

---

正如 Ivan 在 cmets 中指出的那样，boxList 不应该是 class BoxIterator implements Iterator<Box>, Iterable<Box> 类型。你真的应该有：

class BoxList implements Iterable<Box> { ... }
class BoxIterator implements Iterator<Box> { ... }

BoxList boxList = ...;
for (Box box : boxList) {
  for (Drawer drawer : box) {
    drawer.getId()
  }
}

虽然让一个类同时实现 Iterable 和 Iterator 在技术上并不是错误对于您的用例，但它可能会导致混淆。

在另一个上下文中考虑这段代码：

List<Box> boxList = Arrays.asList(box1, box2, box3, box4);
for(Box box : boxList) {
    // Do something
}
for(Box box : boxList) {
    // Do some more stuff
}

在这里，boxList.iterator() 被调用了两次，以创建两个单独的 Iterator<Box> 实例，用于两次迭代框列表。因为boxList 可以迭代多次，每次迭代都需要一个新的迭代器实例。

在您的代码中：

BoxIterator boxList = new BoxIterator(xml_stream);
for (Box box : boxList) {
  for (Drawer drawer : box) {
    drawer.getId();
  }
}

因为您正在对流进行迭代，所以您不能（在不倒带流或存储提取的对象的情况下）第二次迭代相同的节点。不需要第二个类/对象；同一个对象可以同时充当 Iterable 和 Iterator ...这为您节省了一个类/对象。

话虽如此，过早优化是万恶之源。一个类/对象的节省不值得可能的混淆；您应该将BoxIterator 拆分为BoxList implements Iterable<Box> 和BoxIterator implements Iterator<Box>。

Answer 4

由于hasNext() 可以返回true，但next() 可以抛出NoSuchElementException，它有可能违反合同。

hasNext()的合约是：

如果迭代有更多元素，则返回 true。 （换句话说，如果 next() 将返回一个元素而不是抛出异常，则返回 true。）

但是在调用hasNext() 和next() 之间可能会发生另一个迭代器移动了流的位置以致没有更多元素的情况。

但是，以您使用它的方式（嵌套循环），您不会遇到损坏。

如果您要将迭代器传递给另一个进程，那么您可能会遇到这种损坏。