Question

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

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);

}

ConjuntLlista

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

首先：迭代器是一个使用＆＃34;宾语;一旦迭代器读取了一个值，就不能再从该迭代器中读取它;一旦消耗了迭代器，它就无法重用。

迭代器实例应具有内部状态，以便它知道如何回答其三种方法：.hasNext()，.next()，.remove()。

这是一个String数组上的简单迭代器实现，它不支持删除：

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

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

2 个答案: