Nuovo iteratore per la classe Vector

[OmarCore93]

Il testo dell'esercizio:

L'iteratore standard della classe Vector<T> scandisce gli elementi dalla posizione 0 fino alla posizione size() - 1.
Scrivere la classe RevVector<T> che estende Vector<T> e ridefinisce il solo metodo iterator(), restituiendo un oggetto della nuova classe RevVectIterator<T>.
Definire la classe RevVectIterator<T> che implementa Iterator<T>, e realizza un iteratore che scandisce gli elementi di un vettore in ordine inverso a quello standard.

Codice di RevVectIterator<T> che implementa Iterator<T>.

import java.util.*; 

public class RevVectIterator<T> implements Iterator<T>
{
    private Vector<T> v;
    private int curr;

    public RevVectIterator(Vector<T> v)
    {
        this.v = v;
        this.curr = this.v.size() - 1;
    }

    public boolean hasNext()
    {
        return(curr > 0);
    }

    public T next() throws NoSuchElementException
    {
        try
        {
                return (v.get(curr--));
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
                throw new NoSuchElementException();
        }
    }

    public void remove()
    {
        v.remove(curr);
    }
}

Questo codice funziona, l'ho testato richiamando tale classe in modo diretto. Ora devo fare la classe RevVector<T>, quella che ridefinisce solo il metodo iterator() e restituisce un nuovo elemento di tipo RevVectIterator<T>.
Come la faccio? Ho capito che dentro il metodo iterator() che devo ridefinire dovrò creare un nuovo elemento di tipo RevVectIterator<T> e restituirlo, il punto è che il costruttore di RevVectIterator prende un Vector come parametro, cosa gli passo come parametro? Qualcuno può aiutarmi?

[Alex'87]

Gli passerai this (che fa riferimento all'istanza su cui stai chiamando il metodo iterator()).

[OmarCore93]

Gli passerai this (che fa riferimento all'istanza su cui stai chiamando il metodo iterator()).

Lo schema di ciò che volevo fare era così:

import java.util.*; 

public class RevVector<T> extends Vector<T>
{
    public Iterator<T> iterator()
    {
        RevVectIterator<T> it = new RevVectIterator<T>(v);
        return it;
    }
}

I miei dubbi sono: nella classe RevVector devo metterci qualche variabile d'istanza? Inoltre al posto di v devo metterci qualcosa, perchè dovrò passare qualcosa al costruttore RevVectIterator, lì ci metto this? Puoi aiutarmi col codice? Sono ancora un po' nabbo per quanto riguarda l'estensione delle classi, non ho capito ancora bene come funzionano dal lato della sintassi.

[Alex'87]

Sì, se il costruttore di RevVectIterator vuole un Vector al posto di v ci metterai this:

import java.util.Iterator;
import java.util.Vector;

public class RevVector<T> extends Vector<T>
{

    @Override
    public Iterator<T> iterator()
    {
        return new RevVectIterator<T>(this);
    }

}

[OmarCore93]

Grazie mille! Non credevo fosse così semplice, a lezione ho visto la parte relativa alla semantica della extends ma di fatto non avevo mai fatto nulla.
Per visualizzare poi ho fatto una classe del genere dove ho messo il main:

import java.util.*;

class MainVector
{
    public static void main (String [] args)
    {
        RevVector<Integer> v = new RevVector<Integer>();
        for(int i = 0; i<=20; i++) v.add(i);
        Iterator<Integer> it = v.iterator();
        Integer x;
        while(it.hasNext())
        {
            x = new Integer(it.next());
            System.out.println(x);
        }  
    }
}

E funziona.

[Alex'87]

Bene.

Qualche nota.
it.next() restituisce già un Integer, non serve crearne uno nuovo. x = it.next() è sufficiente.
Rivedrei poi un po' l'indentazione e i nomi delle variabili.
Due istruzioni sulla stessa riga inoltre sono poco leggibili, meglio una per riga con le opportune parentesi.

import java.util.Iterator;
import java.util.Vector;

public class MainVector 
{

    public static void main(String[] args) 
    {
        RevVector<Integer> vector = new RevVector<Integer>();
        for (int i = 0; i < 20; i++) 
        {
            vector.add(i);
        }

        Iterator<Integer> iterator = vector.iterator();
        while (iterator.hasNext()) 
        {
            Integer currentValue = iterator.next();
            System.out.println(currentValue);
        }
    }

}

[OmarCore93]

Vabbè le parentesi del blocco nel for non erano necessarie perchè tanto c'è solo un'istruzione dentro. Per i nomi delle variabili non capisco il problema lol, non ho usato nomi troppo stravaganti, in ogni caso non è che c'è uno standard. Per l'indentazione stai tranquillo che ci sto molto attento a scrivere in modo abbastanza ordinato.

[Alex'87]

Vabbè le parentesi del blocco nel for non era necessarie perchè tanto c'è solo un'istruzione dentro. Per i nomi delle variabili non capisco il problema lol, non ho usato nomi troppo stravaganti, in ogni caso non è che c'è uno standard. Per l'indentazione stai tranquillo che ci sto molto attento a scrivere in modo abbastanza ordinato.

E' che sono talebano io su queste cose

Io le metto sempre le parentesi, anche se c'è una sola istruzione (vale per il for come per if, while ecc): è più chiaro qual è il corpo del ciclo ed evita errori subdoli. Esempio:

if (x == 10)
    if (y == 20)
        z = 30;
else 
    z = 40;

A dispetto dell'indentazione l'else è dell'if più interno. L'uso delle parentesi aiuta ad esplicitare meglio le nostre intenzioni.

Riguardo i nomi, "v" non è un bel nome per una variabile perché non ci dice cos'è.
L'unica eccezione è l'uso di i,j, k ecc come variabili di ciclo per accedere ad un array/matrice.

[OmarCore93]

Fai benissimo ad essere ordinato, w i programmatori ordinati! A volte alcuni colleghi di Università mi hanno chiesto di esaminare certi loro codici che non ti dico, del tipo che la prima cosa che noti è il disordine e ti fa passare la voglia di metterci mano.
Comunque pure io a volte uso mettere le parentesi graffe anche se non strettamente necessario, per dire, nell'esempio che hai fatto lo farei pure io, è troppo ambiguo in quel caso e secondo me non è tollerabile che uno debba perdere tempo a capire solamente cose del genere, uno deve analizzare il codice, non può perdere tempo a capire cose relative alla sintassi! Poi nel mio caso ho preferito non mettere le parentesi perchè tanto era abbastanza chiaro visto che dentro il for non c'era molta roba ma solo un assegnamento.