Wie iteriere ich durch SparseArray?

Gibt es eine Möglichkeit, über Java SparseArray (für Android) zu iterieren? Früher habe ich sparsearrayleicht Werte nach Index erhalten. Ich konnte keinen finden.

Scheint, als hätte ich die Lösung gefunden. Ich hatte die keyAt(index)Funktion nicht richtig bemerkt .

Also gehe ich mit so etwas:

for(int i = 0; i < sparseArray.size(); i++) {
   int key = sparseArray.keyAt(i);
   // get the object by the key.
   Object obj = sparseArray.get(key);
}

Wenn Sie sich nicht für die Schlüssel interessieren, valueAt(int)können Sie beim Durchlaufen des spärlichen Arrays direkt auf die Werte zugreifen.

for(int i = 0, nsize = sparseArray.size(); i < nsize; i++) {
    Object obj = sparseArray.valueAt(i);
}

Oder Sie erstellen einfach Ihren eigenen ListIterator:

public final class SparseArrayIterator<E> implements ListIterator<E> {

private final SparseArray<E> array;
private int cursor;
private boolean cursorNowhere;

/**
 * @param array
 *            to iterate over.
 * @return A ListIterator on the elements of the SparseArray. The elements
 *         are iterated in the same order as they occur in the SparseArray.
 *         {@link #nextIndex()} and {@link #previousIndex()} return a
 *         SparseArray key, not an index! To get the index, call
 *         {@link android.util.SparseArray#indexOfKey(int)}.
 */
public static <E> ListIterator<E> iterate(SparseArray<E> array) {
    return iterateAt(array, -1);
}

/**
 * @param array
 *            to iterate over.
 * @param key
 *            to start the iteration at. {@link android.util.SparseArray#indexOfKey(int)}
 *            < 0 results in the same call as {@link #iterate(android.util.SparseArray)}.
 * @return A ListIterator on the elements of the SparseArray. The elements
 *         are iterated in the same order as they occur in the SparseArray.
 *         {@link #nextIndex()} and {@link #previousIndex()} return a
 *         SparseArray key, not an index! To get the index, call
 *         {@link android.util.SparseArray#indexOfKey(int)}.
 */
public static <E> ListIterator<E> iterateAtKey(SparseArray<E> array, int key) {
    return iterateAt(array, array.indexOfKey(key));
}

/**
 * @param array
 *            to iterate over.
 * @param location
 *            to start the iteration at. Value < 0 results in the same call
 *            as {@link #iterate(android.util.SparseArray)}. Value >
 *            {@link android.util.SparseArray#size()} set to that size.
 * @return A ListIterator on the elements of the SparseArray. The elements
 *         are iterated in the same order as they occur in the SparseArray.
 *         {@link #nextIndex()} and {@link #previousIndex()} return a
 *         SparseArray key, not an index! To get the index, call
 *         {@link android.util.SparseArray#indexOfKey(int)}.
 */
public static <E> ListIterator<E> iterateAt(SparseArray<E> array, int location) {
    return new SparseArrayIterator<E>(array, location);
}

private SparseArrayIterator(SparseArray<E> array, int location) {
    this.array = array;
    if (location < 0) {
        cursor = -1;
        cursorNowhere = true;
    } else if (location < array.size()) {
        cursor = location;
        cursorNowhere = false;
    } else {
        cursor = array.size() - 1;
        cursorNowhere = true;
    }
}

@Override
public boolean hasNext() {
    return cursor < array.size() - 1;
}

@Override
public boolean hasPrevious() {
    return cursorNowhere && cursor >= 0 || cursor > 0;
}

@Override
public int nextIndex() {
    if (hasNext()) {
        return array.keyAt(cursor + 1);
    } else {
        throw new NoSuchElementException();
    }
}

@Override
public int previousIndex() {
    if (hasPrevious()) {
        if (cursorNowhere) {
            return array.keyAt(cursor);
        } else {
            return array.keyAt(cursor - 1);
        }
    } else {
        throw new NoSuchElementException();
    }
}

@Override
public E next() {
    if (hasNext()) {
        if (cursorNowhere) {
            cursorNowhere = false;
        }
        cursor++;
        return array.valueAt(cursor);
    } else {
        throw new NoSuchElementException();
    }
}

@Override
public E previous() {
    if (hasPrevious()) {
        if (cursorNowhere) {
            cursorNowhere = false;
        } else {
            cursor--;
        }
        return array.valueAt(cursor);
    } else {
        throw new NoSuchElementException();
    }
}

@Override
public void add(E object) {
    throw new UnsupportedOperationException();
}

@Override
public void remove() {
    if (!cursorNowhere) {
        array.remove(array.keyAt(cursor));
        cursorNowhere = true;
        cursor--;
    } else {
        throw new IllegalStateException();
    }
}

@Override
public void set(E object) {
    if (!cursorNowhere) {
        array.setValueAt(cursor, object);
    } else {
        throw new IllegalStateException();
    }
}
}

Einfach wie Torte. Stellen Sie einfach sicher, dass Sie die Arraygröße abrufen, bevor Sie die Schleife tatsächlich ausführen.

for(int i = 0, arraySize= mySparseArray.size(); i < arraySize; i++) {
   Object obj = mySparseArray.get(/* int key = */ mySparseArray.keyAt(i));
}

Hoffe das hilft.

Für jeden, der Kotlin verwendet, ist der mit Abstand einfachste Weg, über ein SparseArray zu iterieren, ehrlich: Verwenden Sie die Kotlin-Erweiterung von Anko oder Android KTX ! (Dank an Yazazzello für den Hinweis auf Android KTX)

Einfach anrufen forEach { i, item -> }

Zum Entfernen aller Elemente aus der SparseArrayVerwendung führt die obige Schleife zu Exception.

Um dies zu vermeiden, befolgen Sie den folgenden Code, um alle Elemente aus der SparseArrayVerwendung normaler Schleifen zu entfernen

private void getValues(){      
    for(int i=0; i<sparseArray.size(); i++){
          int key = sparseArray.keyAt(i);
          Log.d("Element at "+key, " is "+sparseArray.get(key));
          sparseArray.remove(key);
          i=-1;
    }
}

Hier ist einfach Iterator<T>und Iterable<T>Implementierungen für SparseArray<T>:

public class SparseArrayIterator<T> implements Iterator<T> {
    private final SparseArray<T> array;
    private int index;

    public SparseArrayIterator(SparseArray<T> array) {
        this.array = array;
    }

    @Override
    public boolean hasNext() {
        return array.size() > index;
    }

    @Override
    public T next() {
        return array.valueAt(index++);
    }

    @Override
    public void remove() {
        array.removeAt(index);
    }

}

public class SparseArrayIterable<T> implements Iterable<T> {
    private final SparseArray<T> sparseArray;

    public SparseArrayIterable(SparseArray<T> sparseArray) {
        this.sparseArray = sparseArray;
    }

    @Override
    public Iterator<T> iterator() {
        return new SparseArrayIterator<>(sparseArray);
    }
}

Wenn Sie nicht nur einen Wert, sondern auch einen Schlüssel iterieren möchten:

public class SparseKeyValue<T> {
    private final int key;
    private final T value;

    public SparseKeyValue(int key, T value) {
        this.key = key;
        this.value = value;
    }

    public int getKey() {
        return key;
    }

    public T getValue() {
        return value;
    }
}

public class SparseArrayKeyValueIterator<T> implements Iterator<SparseKeyValue<T>> {
    private final SparseArray<T> array;
    private int index;

    public SparseArrayKeyValueIterator(SparseArray<T> array) {
        this.array = array;
    }

    @Override
    public boolean hasNext() {
        return array.size() > index;
    }

    @Override
    public SparseKeyValue<T> next() {
        SparseKeyValue<T> keyValue = new SparseKeyValue<>(array.keyAt(index), array.valueAt(index));
        index++;
        return keyValue;
    }

    @Override
    public void remove() {
        array.removeAt(index);
    }

}

public class SparseArrayKeyValueIterable<T> implements Iterable<SparseKeyValue<T>> {
    private final SparseArray<T> sparseArray;

    public SparseArrayKeyValueIterable(SparseArray<T> sparseArray) {
        this.sparseArray = sparseArray;
    }

    @Override
    public Iterator<SparseKeyValue<T>> iterator() {
        return new SparseArrayKeyValueIterator<T>(sparseArray);
    }
}

Es ist nützlich, Dienstprogrammmethoden zu erstellen, die Folgendes zurückgeben Iterable<T>und Iterable<SparseKeyValue<T>>:

public abstract class SparseArrayUtils {
    public static <T> Iterable<SparseKeyValue<T>> keyValueIterable(SparseArray<T> sparseArray) {
        return new SparseArrayKeyValueIterable<>(sparseArray);
    }

    public static <T> Iterable<T> iterable(SparseArray<T> sparseArray) {
        return new SparseArrayIterable<>(sparseArray);
    }
}

Jetzt können Sie iterieren SparseArray<T>:

SparseArray<String> a = ...;

for (String s: SparseArrayUtils.iterable(a)) {
   // ...
}

for (SparseKeyValue<String> s: SparseArrayUtils.keyValueIterable(a)) {
  // ...
}

Wenn Sie Kotlin verwenden, können Sie Erweiterungsfunktionen als solche verwenden, zum Beispiel:

fun <T> LongSparseArray<T>.valuesIterator(): Iterator<T> {
    val nSize = this.size()
    return object : Iterator<T> {
        var i = 0
        override fun hasNext(): Boolean = i < nSize
        override fun next(): T = valueAt(i++)
    }
}

fun <T> LongSparseArray<T>.keysIterator(): Iterator<Long> {
    val nSize = this.size()
    return object : Iterator<Long> {
        var i = 0
        override fun hasNext(): Boolean = i < nSize
        override fun next(): Long = keyAt(i++)
    }
}

fun <T> LongSparseArray<T>.entriesIterator(): Iterator<Pair<Long, T>> {
    val nSize = this.size()
    return object : Iterator<Pair<Long, T>> {
        var i = 0
        override fun hasNext(): Boolean = i < nSize
        override fun next() = Pair(keyAt(i), valueAt(i++))
    }
}

Wenn Sie möchten, können Sie auch in eine Liste konvertieren. Beispiel:

sparseArray.keysIterator().asSequence().toList()

Ich denke , es könnte sogar zu löschen Gegenstände sicher sein , mit removeauf der LongSparseArrayselbst (nicht auf dem Iterator), wie sie in aufsteigender Reihenfolge ist.

BEARBEITEN: Es scheint noch einfacher zu sein, mit collection-ktx (Beispiel hier) ). Es ist sehr ähnlich implementiert wie das, was ich tatsächlich geschrieben habe.

Gradle benötigt dies:

implementation 'androidx.core:core-ktx:#'
implementation 'androidx.collection:collection-ktx:#'

Hier ist die Verwendung für LongSparseArray:

    val sparse= LongSparseArray<String>()
    for (key in sparse.keyIterator()) {
    }
    for (value in sparse.valueIterator()) {
    }
    sparse.forEach { key, value -> 
    }

Und für diejenigen , die Java verwenden, können Sie verwenden LongSparseArrayKt.keyIterator, LongSparseArrayKt.valueIteratorund LongSparseArrayKt.forEachzum Beispiel. Gleiches gilt für die anderen Fälle.

Die Antwort ist nein, weil SparseArrayes nicht liefert. Wie pstgesagt, dieses Ding bietet keine Schnittstellen.

Sie könnten 0 - size()Werte, die zurückgeben null, durchlaufen und überspringen , aber das ist es auch.

Wie ich in meinem Kommentar feststelle, verwenden Sie a Mapanstelle von a , wenn Sie iterieren müssen SparseArray. Verwenden Sie beispielsweise a, TreeMapdas in der Reihenfolge des Schlüssels iteriert.

TreeMap<Integer, MyType>

Die akzeptierte Antwort enthält einige Lücken. Das Schöne am SparseArray ist, dass es Lücken in den Unanständigkeiten zulässt. Wir könnten also zwei Karten wie diese in einem SparseArray haben ...

(0,true)
(250,true)

Beachten Sie, dass die Größe hier 2 wäre. Wenn wir über die Größe iterieren, erhalten wir nur Werte für die Werte, die Index 0 und Index 1 zugeordnet sind. Auf die Zuordnung mit einem Schlüssel von 250 wird also nicht zugegriffen.

for(int i = 0; i < sparseArray.size(); i++) {
   int key = sparseArray.keyAt(i);
   // get the object by the key.
   Object obj = sparseArray.get(key);
}

Der beste Weg, dies zu tun, besteht darin, über die Größe Ihres Datensatzes zu iterieren und diese Unabhängigkeiten dann mit einem get () im Array zu überprüfen. Hier ist ein Beispiel mit einem Adapter, bei dem ich das Batch-Löschen von Elementen erlaube.

for (int index = 0; index < mAdapter.getItemCount(); index++) {
     if (toDelete.get(index) == true) {
        long idOfItemToDelete = (allItems.get(index).getId());
        mDbManager.markItemForDeletion(idOfItemToDelete);
        }
    }

Ich denke, im Idealfall hätte die SparseArray-Familie eine getKeys () -Methode, aber leider nicht.