Iterator metodo successivo

Question

In ResultSet interfaccia v'è next metodo che tornare booleano e poi si può accedere direttamente al record corrente get metodi

Perché Iterator da java.util proprio non cadere hasNext() metodo e hanno solo next metodo che si sposta il cursore sull'elemento successivo e restituire boolean?

Answer 1

Perché next() attualmente restituisce l'elemento successivo.

Java poteva hanno attuato il modello iteratore nello stesso modo in cui .NET fa, con un MoveNext() che restituisce un valore booleano, e quindi una proprietà Current con il valore "corrente" - ma è ancora due membri ...

L'altra alternativa ha un valore di ritorno che incapsula le due idee di "c'è un valore" e "qual è il valore se ce n'è uno" - una sorta di tipo Maybe, davvero. Naturalmente in Java, che significa che attribuisce un nuovo oggetto su ogni iterazione, che non è ideale ...

Answer 2

Procedimento ResultSetnext() è come hasNext() di iteratore. La maggior parte degli altri metodi di ResultSet invece del singolo metodo next() di Iterator.

Vorrei fare un'altra domanda: perché non hanno implementato l'iteratore ResultSet o almeno iterabile con i generici? Penso che la risposta sia che ResultSet appare in java prima di Iterator. Poco dopo sono stati introdotti molti strumenti tipo ORM, quindi la maggior parte delle persone semplicemente non usa JDBC direttamente e non si occupa di ResultSet.

Ma io non sono storico di JDK, quindi è la mia ipotesi.

Answer 3

Perché avresti ancora bisogno di un'altra funzione per recuperare il valore, quindi non si otterrebbe nulla.

In un ResultSet, next() porta al record successivo o restituisce false se non ce n'è. Quindi fai getString(), getInt() o qualsiasi altra cosa per recuperare i valori del campo. Così si scrive il codice del tipo:

while (rs.next()) 
{ 
    name=rs.getString("name"); // or whatever 
    ... do something with name ... 
} 

In un Iterator, hasNext() restituisce un vero o falso per indicare se c'è un altro record. Quindi si chiama next() per recuperare il valore. così si scrive il codice del tipo:

while (iter.hasnext()) 
{ 
    name=iter.next(); // or whatever 
    ... do something with name ... 
} 

Il modello finisce per essere piuttosto simili. È un peccato che le implementazioni siano incoerenti. Vale a dire, ResultSet.next non solo ti dice se sei alla fine ma avanza anche il positoin, mentre Iterator.hasNext ti dice se sei alla fine ma non avanza la posizione. Ma l'uso effettivo è abbastanza simile.

Non sarebbe davvero utile provare a combinare Iterator.hasNext e Iterator.next in un'unica funzione. Come faresti a sapere quando hai raggiunto la fine? Si potrebbe dire che restituisce null alla fine ... ma cosa succede se null è un valore valido nella lista? Suppongo che potresti aggiungere un po 'di valore magico, ma avresti comunque il problema di distinguere il significato magico da una voce nella lista che è appena capita di avere quel valore. Come se tu avessi una lista di ints, potresti dire che -1 significa end-of-list, ma che succede se l'elenco include un valore di -1?

L'unica altra alternativa che vedo è che la funzione next() restituisca un oggetto che include sia un'indicazione di fine elenco che, se applicabile, il valore. Ma questo sarebbe un dolore da usare. Dovresti scrivere qualcosa del tipo:

while (true) 
{ 
    IterableResult ir=iter.next(); 
    if (ir.end) 
    { 
    break; 
    } 
    else 
    { 
    name=ir.value; 
    ... do something with name ... 
    } 
} 

Questo non sembra guadagnare nulla.

Forse c'è un altro approccio che funzionerebbe meglio, ma non riesco a pensarne uno. E a quanto pare anche i creatori dell'interfaccia Iterator non hanno potuto pensare a un modo migliore! :-)