Was ist der beste Weg, um einen Android-Cursor zu iterieren?

Ich sehe häufig Code, bei dem das Ergebnis einer Datenbankabfrage durchlaufen wird, mit jeder Zeile etwas getan wird und dann mit der nächsten Zeile fortgefahren wird. Typische Beispiele sind wie folgt.

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

Diese scheinen mir alle übermäßig langwierig zu sein, jeder mit mehreren CursorMethodenaufrufen. Sicherlich muss es einen saubereren Weg geben?

Der einfachste Weg ist folgender:

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

Der Cursor startet vor der ersten Ergebniszeile. Bei der ersten Iteration wird zum ersten Ergebnis gewechselt, falls vorhanden . Wenn der Cursor leer ist oder die letzte Zeile bereits verarbeitet wurde, wird die Schleife ordnungsgemäß beendet.

Vergessen Sie natürlich nicht, den Cursor zu schließen, wenn Sie damit fertig sind, vorzugsweise in einer finallyKlausel.

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

Wenn Sie auf API 19+ abzielen, können Sie Try-with-Resources verwenden.

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

Der beste Weg, den ich gefunden habe, um durch einen Cursor zu gehen, ist der folgende:

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

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

Vergessen Sie nicht, den Cursor danach zu schließen

BEARBEITEN: Die angegebene Lösung ist großartig, wenn Sie jemals einen Cursor iterieren müssen, für den Sie nicht verantwortlich sind. Ein gutes Beispiel wäre, wenn Sie einen Cursor als Argument in einer Methode verwenden und den Cursor nach einem bestimmten Wert durchsuchen müssen, ohne sich um die aktuelle Position des Cursors kümmern zu müssen.

Ich möchte nur auf eine dritte Alternative hinweisen, die auch funktioniert, wenn sich der Cursor nicht an der Startposition befindet:

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

Wie wäre es mit foreach loop:

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

Meine Version von CursorUtils sollte jedoch weniger hässlich sein, schließt jedoch automatisch den 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;
    }
}
}

Unten könnte der bessere Weg sein:

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

Der obige Code würde sicherstellen, dass er die gesamte Iteration durchläuft und nicht der ersten und letzten Iteration entgeht.

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

Beispielcode:

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

Die Do / While-Lösung ist eleganter, aber wenn Sie nur die oben angegebene While-Lösung verwenden, wird ohne die moveToPosition (-1) das erste Element übersehen (zumindest in der Kontaktabfrage).

Ich schlage vor:

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

Der Cursor ist die Schnittstelle, die eine 2-dimensionalTabelle einer beliebigen Datenbank darstellt.

Wenn Sie versuchen, einige Daten mithilfe einer SELECTAnweisung abzurufen , erstellt die Datenbank zunächst ein CURSOR-Objekt und gibt dessen Referenz an Sie zurück.

Der Zeiger dieser zurückgegebenen Referenz zeigt auf die 0. Stelle die ansonsten wie vor der ersten Position des Cursors aufgerufen wird. Wenn Sie also Daten vom Cursor abrufen möchten, müssen Sie zuerst zum 1. Datensatz wechseln, damit wir sie verwenden können moveToFirst

Wenn Sie eine moveToFirst()Methode für den Cursor aufrufen , wird der Cursorzeiger an die erste Stelle geführt. Jetzt können Sie auf die im 1. Datensatz vorhandenen Daten zugreifen

Der beste Weg, um zu schauen:

Cursor Cursor

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

Am Anfang Cursor ist nicht auf der ersten Zeile zeigt mit moveToNext()den Cursor durchlaufen kann , wenn Datensatz nicht existiert dann return false, wenn sie nicht return true,

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