Bagaimana cara mengulang melalui SparseArray?

Apakah ada cara untuk beralih ke Java SparseArray (untuk Android)? Saya terbiasa sparsearraydengan mudah mendapatkan nilai berdasarkan indeks. Saya tidak dapat menemukannya.

Sepertinya saya menemukan solusinya. Saya belum benar-benar memperhatikan keyAt(index)fungsinya.

Jadi saya akan pergi dengan sesuatu seperti ini:

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

Jika Anda tidak peduli dengan kunci, maka valueAt(int)dapat digunakan untuk sementara iterasi melalui array jarang untuk mengakses nilai secara langsung.

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

Atau Anda baru saja membuat ListIterator Anda sendiri:

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

Sederhana seperti Pie. Pastikan Anda mengambil ukuran array sebelum benar-benar melakukan loop.

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

Semoga ini membantu.

Bagi siapa pun yang menggunakan Kotlin, jujur ​​cara termudah untuk beralih di SparseArray adalah: Gunakan ekstensi Kotlin dari Anko atau Android KTX ! (kredit untuk Yazazzello karena menunjukkan Android KTX)

Cukup telepon forEach { i, item -> }

Untuk menghapus semua elemen dari SparseArraymenggunakan mengarah perulangan di atas Exception.

Untuk menghindari ini Ikuti kode di bawah ini untuk menghapus semua elemen dari SparseArraymenggunakan loop normal

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

Berikut ini sederhana Iterator<T>dan Iterable<T>implementasi untuk 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);
    }
}

Jika Anda ingin mengulangi tidak hanya nilai tetapi juga kunci:

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

Berguna untuk membuat metode utilitas yang mengembalikan Iterable<T>dan 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);
    }
}

Sekarang Anda dapat mengulangi SparseArray<T>:

SparseArray<String> a = ...;

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

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

Jika Anda menggunakan Kotlin, Anda dapat menggunakan fungsi ekstensi seperti itu, misalnya:

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++))
    }
}

Anda juga dapat mengonversi ke daftar, jika diinginkan. Contoh:

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

Saya pikir itu bahkan mungkin aman untuk item menghapus menggunakan removepada LongSparseArrayitu sendiri (bukan pada iterator), seperti di urutan menaik.

EDIT: Sepertinya ada cara yang lebih mudah, dengan menggunakan collection-ktx (contoh di sini ). Ini diterapkan dengan cara yang sangat mirip dengan apa yang saya tulis, secara aktif.

Gradle membutuhkan ini:

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

Inilah penggunaan untuk LongSparseArray:

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

Dan bagi mereka yang menggunakan Java, Anda dapat menggunakan LongSparseArrayKt.keyIterator, LongSparseArrayKt.valueIteratordan LongSparseArrayKt.forEach, misalnya. Sama untuk kasus lainnya.

Jawabannya adalah tidak karena SparseArraytidak menyediakannya. Seperti yang pstdikatakan, benda ini tidak menyediakan antarmuka apa pun.

Anda bisa mengulang dari 0 - size()dan melewatkan nilai yang kembali null, tetapi hanya itu saja.

Seperti yang saya nyatakan dalam komentar saya, jika Anda perlu menggunakan it Mapbukan a SparseArray. Misalnya, gunakan TreeMaptombol yang diurutkan berdasarkan kunci.

TreeMap<Integer, MyType>

Jawaban yang diterima memiliki beberapa lubang di dalamnya. Keindahan SparseArray adalah memungkinkan celah di indeces. Jadi, kita bisa memiliki dua peta seperti itu, dalam SparseArray ...

(0,true)
(250,true)

Perhatikan bahwa ukuran di sini adalah 2. Jika kita mengulangi ukuran lebih, kita hanya akan mendapatkan nilai untuk nilai yang dipetakan ke indeks 0 dan indeks 1. Jadi pemetaan dengan kunci 250 tidak diakses.

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

Cara terbaik untuk melakukan ini adalah untuk mengulangi ukuran set data Anda, kemudian periksa indeces tersebut dengan get () pada array. Berikut ini adalah contoh dengan adaptor di mana saya mengizinkan penghapusan beberapa item.

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

Saya pikir idealnya keluarga SparseArray akan memiliki metode getKeys (), tetapi sayangnya tidak.