Qual è il modo migliore per iterare un cursore Android?

Vedo spesso il codice che comporta l'iterazione sul risultato di una query del database, l'esecuzione di operazioni con ciascuna riga e il passaggio alla riga successiva. Esempi tipici sono i seguenti.

Cursor cursor = db.rawQuery(...);
cursor.moveToFirst();
while (cursor.isAfterLast() == false) 
{
    ...
    cursor.moveToNext();
}

Cursor cursor = db.rawQuery(...);
for (boolean hasItem = cursor.moveToFirst(); 
     hasItem; 
     hasItem = cursor.moveToNext()) {
    ...
}

Cursor cursor = db.rawQuery(...);
if (cursor.moveToFirst()) {
    do {
        ...                 
    } while (cursor.moveToNext());
}

Tutto questo mi sembra eccessivamente prolisso, ognuno con più chiamate ai Cursormetodi. Sicuramente ci deve essere un modo più ordinato?

Il modo più semplice è questo:

while (cursor.moveToNext()) {
    ...
}

Il cursore inizia prima della prima riga del risultato, quindi sulla prima iterazione questo si sposta sul primo risultato se esiste . Se il cursore è vuoto o l'ultima riga è già stata elaborata, il loop si chiude in modo ordinato.

Naturalmente, non dimenticare di chiudere il cursore una volta terminato, preferibilmente in una finallyclausola.

Cursor cursor = db.rawQuery(...);
try {
    while (cursor.moveToNext()) {
        ...
    }
} finally {
    cursor.close();
}

Se scegli come target API 19+, puoi utilizzare try-with-resources.

try (Cursor cursor = db.rawQuery(...)) {
    while (cursor.moveToNext()) {
        ...
    }
}

Il modo più bello che ho trovato per passare attraverso un cursore è il seguente:

Cursor cursor;
... //fill the cursor here

for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
    // do what you need with the cursor here
}

Non dimenticare di chiudere il cursore dopo

EDIT: la soluzione data è ottima se hai mai bisogno di iterare un cursore di cui non sei responsabile. Un buon esempio potrebbe essere, se stai prendendo un cursore come argomento in un metodo e devi scansionare il cursore per un dato valore, senza preoccuparti della posizione corrente del cursore.

Vorrei solo sottolineare una terza alternativa che funziona anche se il cursore non si trova nella posizione iniziale:

if (cursor.moveToFirst()) {
    do {
        // do what you need with the cursor here
    } while (cursor.moveToNext());
}

Che ne dici di usare foreach loop:

Cursor cursor;
for (Cursor c : CursorUtils.iterate(cursor)) {
    //c.doSth()
}

Tuttavia la mia versione di CursorUtils dovrebbe essere meno brutta, ma chiude automaticamente il cursore:

public class CursorUtils {
public static Iterable<Cursor> iterate(Cursor cursor) {
    return new IterableWithObject<Cursor>(cursor) {
        @Override
        public Iterator<Cursor> iterator() {
            return new IteratorWithObject<Cursor>(t) {
                @Override
                public boolean hasNext() {
                    t.moveToNext();
                    if (t.isAfterLast()) {
                        t.close();
                        return false;
                    }
                    return true;
                }
                @Override
                public Cursor next() {
                    return t;
                }
                @Override
                public void remove() {
                    throw new UnsupportedOperationException("CursorUtils : remove : ");
                }
                @Override
                protected void onCreate() {
                    t.moveToPosition(-1);
                }
            };
        }
    };
}

private static abstract class IteratorWithObject<T> implements Iterator<T> {
    protected T t;
    public IteratorWithObject(T t) {
        this.t = t;
        this.onCreate();
    }
    protected abstract void onCreate();
}

private static abstract class IterableWithObject<T> implements Iterable<T> {
    protected T t;
    public IterableWithObject(T t) {
        this.t = t;
    }
}
}

Di seguito potrebbe essere il modo migliore:

if (cursor.moveToFirst()) {
   while (!cursor.isAfterLast()) {
         //your code to implement
         cursor.moveToNext();
    }
}
cursor.close();

Il codice sopra assicurerebbe che avrebbe attraversato l'intera iterazione e non sfuggire alla prima e all'ultima iterazione.

import java.util.Iterator;
import android.database.Cursor;

public class IterableCursor implements Iterable<Cursor>, Iterator<Cursor> {
    Cursor cursor;
    int toVisit;
    public IterableCursor(Cursor cursor) {
        this.cursor = cursor;
        toVisit = cursor.getCount();
    }
    public Iterator<Cursor> iterator() {
        cursor.moveToPosition(-1);
        return this;
    }
    public boolean hasNext() {
        return toVisit>0;
    }
    public Cursor next() {
    //  if (!hasNext()) {
    //      throw new NoSuchElementException();
    //  }
        cursor.moveToNext();
        toVisit--;
        return cursor;
    }
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

Codice di esempio:

static void listAllPhones(Context context) {
    Cursor phones = context.getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null, null);
    for (Cursor phone : new IterableCursor(phones)) {
        String name = phone.getString(phone.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
        String phoneNumber = phone.getString(phone.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
        Log.d("name=" + name + " phoneNumber=" + phoneNumber);
    }
    phones.close();
}

La soluzione Do / While è più elegante, ma se usi solo la soluzione While pubblicata sopra, senza moveToPosition (-1) perderai il primo elemento (almeno nella query di contatto).

Suggerisco:

if (cursor.getCount() > 0) {
    cursor.moveToPosition(-1);
    while (cursor.moveToNext()) {
          <do stuff>
    }
}

if (cursor.getCount() == 0)
  return;

cursor.moveToFirst();

while (!cursor.isAfterLast())
{
  // do something
  cursor.moveToNext();
}

cursor.close();

Il cursore è l'interfaccia che rappresenta una 2-dimensionaltabella di qualsiasi database.

Quando si tenta di recuperare alcuni dati utilizzando l' SELECTistruzione, il database creerà prima un oggetto CURSORE e restituirà il riferimento all'utente.

Il puntatore di questo riferimento restituito punta alla posizione 0 che altrimenti viene chiamata come prima della prima posizione del cursore, quindi quando si desidera recuperare i dati dal cursore, è necessario 1 ° passaggio al 1 ° record, quindi dobbiamo usare moveToFirst

Quando si richiama il moveToFirst()metodo sul cursore, porta il puntatore del cursore sulla prima posizione. Ora puoi accedere ai dati presenti nel 1 ° record

Il modo migliore di guardare:

Cursore cursore

for (cursor.moveToFirst(); 
     !cursor.isAfterLast();  
     cursor.moveToNext()) {
                  .........
     }

Inizialmente il cursore non si trova nella prima riga che mostra usando moveToNext()puoi iterare il cursore quando il record non esiste, quindi return false, a meno che return true,

while (cursor.moveToNext()) {
    ...
}