Qual é a melhor maneira de iterar um Cursor do Android?

Frequentemente, vejo o código que envolve a iteração sobre o resultado de uma consulta ao banco de dados, fazendo algo com cada linha e passando para a próxima linha. Exemplos típicos são os seguintes.

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

Tudo isso me parece excessivamente longo, cada um com várias chamadas para Cursormétodos. Certamente deve haver uma maneira mais limpa?

A maneira mais simples é esta:

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

O cursor inicia antes da primeira linha do resultado, portanto, na primeira iteração, ele se move para o primeiro resultado, se existir . Se o cursor estiver vazio ou a última linha já tiver sido processada, o loop será encerrado ordenadamente.

Obviamente, não se esqueça de fechar o cursor quando terminar, de preferência em uma finallycláusula.

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

Se você segmentar a API 19+, poderá usar a tentativa com recursos.

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

A maneira mais bonita que encontrei para percorrer um cursor é a seguinte:

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

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

Não esqueça de fechar o cursor depois

EDIT: A solução fornecida é ótima se você precisar iterar um cursor do qual você não é responsável. Um bom exemplo seria se você estiver usando um cursor como argumento em um método e precisar varrer o cursor em busca de um determinado valor, sem precisar se preocupar com a posição atual do cursor.

Gostaria apenas de apontar uma terceira alternativa que também funciona se o cursor não estiver na posição inicial:

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

Que tal usar o loop foreach:

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

No entanto, minha versão do CursorUtils deve ser menos feia, mas fecha automaticamente o 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;
    }
}
}

Abaixo pode ser a melhor maneira:

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

O código acima garantiria que passaria por toda a iteração e não escaparia da primeira e da última iteração.

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 exemplo:

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

A solução Do / While é mais elegante, mas se você usar apenas a solução While postada acima, sem a moveToPosition (-1), você perderá o primeiro elemento (pelo menos na consulta de contato).

Eu sugiro:

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

O cursor é a interface que representa um2-dimensional tabela de qualquer banco de dados.

Quando você tenta recuperar alguns dados usando a SELECTinstrução, o banco de dados cria primeiro um objeto CURSOR e retorna sua referência a você.

O ponteiro desta referência retornada está apontando para o 0º local que, de outra forma, é chamado como antes do primeiro local do Cursor. Portanto, quando você deseja recuperar dados do cursor, deve primeiro mover-se para o 1º registro, para que possamos usar moveToFirst

Quando você invoca o moveToFirst()método no Cursor, ele leva o ponteiro do cursor para o 1º local. Agora você pode acessar os dados presentes no 1º registro

A melhor maneira de olhar:

Cursor do cursor

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

Inicialmente, o cursor não está no primeiro show de linha usando. moveToNext()Você pode iterar o cursor quando o registro não existir return false, a menos que return true,

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