Làm thế nào để lặp lại thông qua SpzzyArray?

Có cách nào để lặp lại trên Java SpzzyArray (cho Android) không? Tôi đã sử dụng sparsearrayđể dễ dàng nhận được các giá trị theo chỉ mục. Tôi không thể tìm thấy một.

Có vẻ như tôi đã tìm thấy giải pháp. Tôi đã không nhận thấy đúngkeyAt(index) chức năng.

Vì vậy, tôi sẽ đi với một cái gì đó như thế này:

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

Nếu bạn không quan tâm đến các khóa, thì valueAt(int)có thể được sử dụng trong khi lặp qua mảng thưa thớt để truy cập trực tiếp vào các giá trị.

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

Ooor bạn chỉ cần tạo ListIterator của riêng bạn:

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

Đơn giản như Pie. Chỉ cần chắc chắn rằng bạn lấy kích thước mảng trước khi thực sự thực hiện vòng lặp.

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

Hi vọng điêu nay co ich.

Đối với bất cứ ai đang sử dụng Kotlin, thành thật mà nói, cách dễ nhất để lặp lại qua SpzzyArray là: Sử dụng tiện ích mở rộng Kotlin từ Anko hoặc Android KTX ! (ghi có vào Yazazzello vì đã chỉ ra Android KTX)

Chỉ cần gọi forEach { i, item -> }

Để loại bỏ tất cả các yếu tố khỏi SparseArrayviệc sử dụng các vòng lặp ở trên dẫn đếnException .

Để tránh điều này Thực hiện theo mã dưới đây để loại bỏ tất cả các yếu tố khỏi SparseArrayviệc sử dụng các vòng lặp thông thường

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

Đây là đơn giản Iterator<T>và Iterable<T>thực hiện cho 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);
    }
}

Nếu bạn muốn lặp lại không chỉ một giá trị mà còn là một khóa:

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

Thật hữu ích khi tạo các phương thức tiện ích trả về Iterable<T>và 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);
    }
}

Bây giờ bạn có thể lặp lại SparseArray<T>:

SparseArray<String> a = ...;

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

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

Nếu bạn sử dụng Kotlin, bạn có thể sử dụng các chức năng mở rộng như vậy, ví dụ:

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

Bạn cũng có thể chuyển đổi thành một danh sách, nếu bạn muốn. Thí dụ:

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

Tôi nghĩ rằng nó thậm chí có thể được an toàn đến các mục delete sử dụng removetrên LongSparseArraybản thân (không phải trên iterator), vì nó là thứ tự tăng dần.

EDIT: Có vẻ như có một cách dễ dàng hơn, bằng cách sử dụng bộ sưu tập-ktx (ví dụ ở đây ). Nó được thực hiện theo cách rất giống với những gì tôi đã viết, thực tế.

Lớp yêu cầu này:

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

Đây là cách sử dụng cho LongSparseArray:

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

Và đối với những người sử dụng Java, bạn có thể sử dụng LongSparseArrayKt.keyIterator, LongSparseArrayKt.valueIteratorvà LongSparseArrayKt.forEach, ví dụ. Tương tự cho các trường hợp khác.

Câu trả lời là không vì SparseArraykhông cung cấp nó. Nhưpst đã nói, điều này không cung cấp bất kỳ giao diện nào.

Bạn có thể lặp từ 0 - size()và bỏ qua các giá trị trả vềnull , nhưng đó là về nó.

Như tôi nêu trong nhận xét của mình, nếu bạn cần lặp lại, hãy sử dụng Mapthay vì a SparseArray. Ví dụ, sử dụng một TreeMapcái lặp theo thứ tự theo khóa.

TreeMap<Integer, MyType>

Câu trả lời được chấp nhận có một số lỗ hổng trong đó. Vẻ đẹp của SpzzyArray là nó cho phép các khoảng trống trong phân. Vì vậy, chúng ta có thể có hai bản đồ như vậy, trong một SpzzyArray ...

(0,true)
(250,true)

Lưu ý kích thước ở đây sẽ là 2. Nếu chúng tôi lặp lại theo kích thước, chúng tôi sẽ chỉ nhận các giá trị cho các giá trị được ánh xạ tới chỉ số 0 và chỉ mục 1. Vì vậy, ánh xạ với khóa 250 không được truy cập.

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

Cách tốt nhất để làm điều này là lặp lại kích thước của tập dữ liệu của bạn, sau đó kiểm tra các phân số đó bằng get () trên mảng. Dưới đây là một ví dụ với một bộ chuyển đổi nơi tôi cho phép xóa hàng loạt các mục.

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

Tôi nghĩ lý tưởng là gia đình SpzzyArray sẽ có phương thức getKeys (), nhưng than ôi thì không.