¿Cuál es la mejor manera de iterar un cursor de Android?

Frecuentemente veo código que implica iterar sobre el resultado de una consulta a la base de datos, hacer algo con cada fila y luego pasar a la siguiente fila. Ejemplos típicos son los siguientes.

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

Todo esto me parece excesivamente largo, cada uno con múltiples llamadas a Cursormétodos. Seguramente debe haber una manera más ordenada?

La forma más simple es esta:

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

El cursor comienza antes de la primera fila de resultados, por lo que en la primera iteración se mueve al primer resultado si existe . Si el cursor está vacío, o la última fila ya ha sido procesada, entonces el bucle sale de manera ordenada.

Por supuesto, no olvide cerrar el cursor una vez que haya terminado, preferiblemente en una finallycláusula.

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

Si apunta a API 19+, puede usar try-with-resources.

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

La mejor manera que he encontrado para pasar por un cursor es la siguiente:

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

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

No olvides cerrar el cursor después

EDITAR: La solución dada es excelente si alguna vez necesita iterar un cursor del que no es responsable. Un buen ejemplo sería, si está tomando un cursor como argumento en un método, y necesita escanear el cursor para un valor dado, sin tener que preocuparse por la posición actual del cursor.

Solo me gustaría señalar una tercera alternativa que también funciona si el cursor no está en la posición inicial:

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

¿Qué tal usar foreach loop:

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

Sin embargo, mi versión de CursorUtils debería ser menos fea, pero cierra automáticamente el cursor:

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

A continuación podría ser la mejor manera:

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

El código anterior aseguraría que pasaría por una iteración completa y no escaparía a la primera y última iteración.

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

Código de ejemplo:

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 solución Do / While es más elegante, pero si usa solo la solución While publicada anteriormente, sin moveToPosition (-1), perderá el primer elemento (al menos en la consulta de contacto).

Yo sugiero:

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

El cursor es la interfaz que representa una 2-dimensionaltabla de cualquier base de datos.

Cuando intente recuperar algunos datos utilizando una SELECTinstrucción, la base de datos primero creará un objeto CURSOR y le devolverá su referencia.

El puntero de esta referencia devuelta apunta a la ubicación 0 que se llama como antes de la primera ubicación del cursor, por lo que cuando desea recuperar datos del cursor, debe mover primero al primer registro, así que tenemos que usar moveToFirst

Cuando invocas el moveToFirst()método en el cursor, lleva el puntero del cursor a la primera ubicación. Ahora puede acceder a los datos presentes en el primer registro

La mejor forma de mirar:

Cursor del cursor

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

Inicialmente cursor no está en la primera fila Mostrar el uso moveToNext()se puede repetir el cursor al registro no es existir, entonces return false, a menos que return true,

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