SparseArray ile nasıl tekrarlanır?

Java SparseArray üzerinde (Android için) tekrarlamanın bir yolu var mı? Kullandığım sparsearraykolaylıkla dizine göre değerlerini alır. Bir tane bulamadım.

Çözümü buldum. keyAt(index)İşlevi düzgün bir şekilde fark etmemiştim .

Bu yüzden böyle bir şeyle gideceğim:

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

Tuşları umursamıyorsanız valueAt(int), değerlere doğrudan erişmek için seyrek dizi üzerinden yinelenirken kullanılabilir.

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

Kendi ListIterator'ınızı oluşturursunuz:

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

Pasta kadar basit. Sadece döngüyü gerçekleştirmeden önce dizi boyutunu getirdiğinizden emin olun .

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

Bu yardımcı olur umarım.

Kotlin'i kim kullanıyorsa, bir SparseArray üzerinde yinelemenin en kolay yolu şudur: Anko veya Android KTX'ten Kotlin uzantısını kullanın ! (Android KTX'i işaret ettiği için Yazazzello'ya teşekkür ederiz)

Sadece arayın forEach { i, item -> }

SparseArrayYukarıdaki döngüleri kullanmaktan tüm elemanları kaldırmak içinException .

Bunu önlemek SparseArrayiçin Normal döngülerden tüm öğeleri kaldırmak için aşağıdaki kodu izleyin

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

İşte basit Iterator<T>ve Iterable<T>uygulamalar içinSparseArray<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);
    }
}

Sadece bir değeri değil aynı zamanda bir anahtarı da yinelemek istiyorsanız:

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

O dönüşü yarar yöntemlerinin oluşturmak kullanışlı olur Iterable<T>ve 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);
    }
}

Şimdi tekrarlayabilirsiniz SparseArray<T>:

SparseArray<String> a = ...;

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

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

Kotlin kullanıyorsanız, uzantı işlevlerini aşağıdaki gibi kullanabilirsiniz, örneğin:

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

İsterseniz bir listeye de dönüştürebilirsiniz. Misal:

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

Ben bile kullanarak silme öğelere güvenli olabileceğini düşünüyorum removeüzerinde LongSparseArrayartan düzende olduğu gibi, (değil yineleyici üzerine) kendisi.

EDIT: collection-ktx kullanarak daha kolay bir yolu var gibi görünüyor (örnek burada ). Yazdıklarıma, benzer şekilde çok benzer bir şekilde uygulandı.

Gradle şunları gerektirir:

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

İşte LongSparseArray kullanımı:

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

Java kullananlar için, örneğin LongSparseArrayKt.keyIterator, LongSparseArrayKt.valueIteratorve kullanabilirsiniz LongSparseArrayKt.forEach. Diğer durumlar için de aynı.

Cevap hayır çünkü SparseArraybunu sağlamaz. As pstkoymak, bu şey hiçbir arabirimleri sağlamaz.

Sen den döngü olabilir 0 - size()ve karşılığında o değerleri atlamak null, ancak bu konuda olduğunu.

Yorumumda belirttiğim gibi, yinelemeye ihtiyacınız varsa bir Mapyerine kullanın SparseArray. Örneğin TreeMap, tuş tarafından sırayla yinelenen bir kullanın .

TreeMap<Integer, MyType>

Kabul edilen cevapta bazı delikler var. SparseArray'ın güzelliği, girintilerde boşluklara izin vermesidir. Bir SparseArray'de iki haritamız olabilirdi ...

(0,true)
(250,true)

Buradaki boyutun 2 olduğuna dikkat edin. Boyut üzerinden yinelersek, yalnızca dizin 0 ve dizin 1 ile eşlenen değerler için değerler alırız. Bu nedenle, 250 anahtarıyla eşleştirmeye erişilmez.

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

Bunu yapmanın en iyi yolu, veri kümenizin boyutu üzerinde yineleme yapmak, ardından dizindeki bir get () ile bu girintileri kontrol etmektir. Burada, öğelerin toplu olarak silinmesine izin verdiğim bir adaptörle bir örnek var.

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

İdeal olarak SparseArray ailesi getKeys () yöntemi olurdu, ama ne yazık ki yok.