使用迭代器，如何使用它们？

Question

我正在学习 Java，但我对迭代器一无所知，我只在 C++ 中使用过它们。 问题是，我有一些类是 2 个节点列表，上面有一个值，我需要从最小到最大列出它们（1、3、4、5、5、6 .. 它们也可以是字符串但这没关系）。问题是我不知道如何实现一个迭代器来遍历并打印每个节点。以下是我的课程：

interface Conjunt<T> {
  // Descripcio general: contenidor generic sense elements repetits

  // Pre : ---
  // Post:  x  pertany al conjunt
  void afegir(T x);

  // Pre : ---
  // Post:  x  no pertany al conjunt
  void esborrar(T x);

  // Pre : ---
  // Post: diu si  x  pertany al conjunt
  boolean pertany(T x);

}

连体字

public class ConjuntLlista<T> implements Conjunt<T> {
    // Descripcio general: conjunt implementat en forma de llista de nodes encadenats

    protected Node primer; // Primer node de la llista

    class Node {
    // Descripcio general: un node de la llista

    T valor;   // Valor dins la llista
    Node seg;  // Seguent node de la llista

    // Pre : ---
    // Post: Crea un node amb els valors dels parametres
    Node(T valor, Node seg) {
        this.valor = valor;
        this.seg = seg;
    }
    }

    class Pair {
    // Descripcio general: tupla de dos nodes   
    Node first;
    Node second;

    // Pre : ---
    // Post: Crea una tupla amb els valors dels parametres
    Pair(Node first, Node second) {
        this.first = first;
        this.second = second;
    }

    }

    // Pre : ---
    // Post: Crea un conjunt buit
    public ConjuntLlista() {
    primer = null;
    }

    // Les seguents operacions no cal especificar-les perque ja estan
    // especificades a la interface.

    public void afegir(T x) {
    if (!pertany(x)) primer = new Node(x, primer);
    }

    public void esborrar(T x) {
    Pair p = buscar(x);
    if (p.second != null) // Hem trobat  x
        if (p.first != null) //  x  no ocupa la primera posicio
        p.first.seg = p.second.seg;
        else
        primer = p.second.seg;
    }

    public boolean pertany(T x) {
    return buscar(x).second != null;
    }

    // Pre : ---
    // Post: Si el conjunt conte  x  aleshores retorna un parell  p  tal
    //       que  p.first  es el node anterior al que conte  x  i  p.second
    //       es el node que conte  x.  Si algun d'aquests nodes no
    //       existeix, es representa amb null.
    private Pair buscar(T x) {
    Node anterior = null; // Node anterior a l'actual
    Node actual = primer; // Node actual (a examinar)
    while (actual != null && !actual.valor.equals(x)) {
        anterior = actual;
        actual = actual.seg;
    }
    if (actual != null) // Hem trobat  x
        return new Pair(anterior,actual);
    else
        return new Pair(null,null);
    }

}

这是我需要添加迭代器的类，但我不知道该怎么做：

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ConjuntLlistaOrdenat1<T extends Comparable<T>>
    extends ConjuntLlista<T> 
    implements Iterable<T> {

    // Descripcio general: Conjunt que disposa d'un iterador que retorna
    //                     els elements de petit a gran.
    //
    //                     Implementacio en forma de llista ordenada,
    //                     sobreescrivint (com a minim) l'operacio afegir.

    public void afegir(T s) {
        if(this.primer != null) {
            Node q = this.primer;
            while(q.valor.compareTo(s) > 0)
                q = q.seg;
            Node p = q;
            q = new Node(s,p);
        }
    }   

}

我看过一些例子，但我无法理解，请有人为我解释一下吗？

Answer 1

Iterable 接口将强制你的类有一个方法iterator()这个方法必须返回一个实现Iterator 接口的类的对象。

所以您的类 ConjuntLlistaOrdenat1 必须返回一个 Iterator 对象，该对象将用于通过方法 hasNext() 和 遍历您的列表em>下一个（）

你必须实现这个类和这两个方法。

我觉得很难理解您的代码，但我认为您的 Iterator 类可能是您的 ConjuntLlista 的 adapter。

Answer 2

首先：迭代器是一个“一次性”的对象；一旦迭代器读取了一个值，就不能再从该迭代器中读取它；迭代器一旦被消耗，就不能被重用。

迭代器实例应该有一个内部状态，以便它知道如何响应它的三个方法：.hasNext()、.next()、.remove()。

下面是对Strings 数组的简单迭代器实现，它不支持删除：

public class MyStringIterator
    implements Iterator<String>
{
    // What we iterate against
    private final String[] array;
    private final int size;
    // The only internal state variable
    private int currentIndex = 0;

    public MyStringIterator(final String[] array)
    {
        this.array = Arrays.copyOf(array);
        size = this.array.length;
    }

    @Override
    public boolean hasNext()
    {
        return currentIndex < size;
    }

    @Override
    public String next()
    {
        if (!hasNext())
            throw new NoSuchElementException();
        return array[currentIndex++];
    }

    @Override
    public void remove()
    {
        throw new UnsupportedOperationException();
    }
}