Android
Come usare SparseArray
Ricerca…
introduzione
Un SparseArray è un'alternativa per una Map . Una Map richiede che le sue chiavi siano oggetti. Il fenomeno dell'autoboxing si verifica quando vogliamo usare un valore int primitivo come chiave. Il compilatore converte automaticamente i valori primitivi nei loro tipi di box (ad es. int in Integer ). La differenza nel footprint della memoria è notevole: int usa 4 byte, Integer usa 16 byte. Un SparseArray utilizza int come valore chiave.
Osservazioni
Vantaggio:
- Meno utilizzo della memoria (a causa delle chiavi primitive).
- Nessun auto-box.
Svantaggio:
- SparseArray utilizza la ricerca binaria per trovare il valore (O (log n)), quindi potrebbe non essere la soluzione migliore se si deve lavorare con un numero elevato di elementi (usare HashMap).
Esistono diverse varianti della famiglia: -SparseArray <Integer, Object> -SparseBooleanArray <Integer, Boolean> -SparseIntArray <Integer, Integer> -SparseLongArray <Integer, Long> -LongSparseArray <Long, Object> -LongSparseLongArray <Long, Long >
Operazioni SparseArray
aggiungendo element - put (int, x): aggiunge una mappatura dalla chiave specificata al valore specificato, sostituendo la mappatura precedente dalla chiave specificata se ce n'era una. - append (int, x): inserisce una coppia chiave / valore nell'array, ottimizzando il caso in cui la chiave è maggiore di tutte le chiavi esistenti nell'array. Dovresti usare append () in caso di chiavi sequenziali per ottimizzare le prestazioni. Altrimenti put () va bene.
remove element - delete (int): rimuove il mapping dalla chiave specificata, se ce n'era. - removeAt (int): rimuove il mapping sull'indice specificato. - removeAtRange (int, int): rimuove un intervallo di mapping come batch.
accessing element - get (int): Ottiene l'int mappato dalla chiave specificata, o 0 se non è stata effettuata alcuna mappatura. - get (int, E): ottiene l'int mappato dalla chiave specificata, o il valore specificato se non è stata effettuata alcuna mappatura. - valueAt (int): Dato un indice compreso nell'intervallo 0 ... size () - 1, restituisce il valore dal mapping di valori-chiave indexth che questo SparseIntArray memorizza. Gli indici sono ordinati in ordine crescente.
ricerca indice / chiave - keyAt (int): Dato un indice compreso nell'intervallo 0 ... size () - 1, restituisce la chiave dal mapping del valore-chiave indexth memorizzato da SparseIntArray. Gli indici sono ordinati in ordine crescente. - valueAt (int): Dato un indice compreso nell'intervallo 0 ... size () - 1, restituisce il valore dal mapping di valori-chiave indexth che questo SparseIntArray memorizza. Gli indici sono ordinati in ordine crescente. - indexOfKey (int): restituisce l'indice per il quale keyAt (int) restituisce la chiave specificata o un numero negativo se la chiave specificata non è mappata. - indexOfValue (E): restituisce un indice per il quale valueAt (int) restituisce la chiave specificata o un numero negativo se nessuna chiave esegue la mappatura sul valore specificato. Fai attenzione che questa è una ricerca lineare, a differenza delle ricerche per chiave, e che più chiavi possono mappare allo stesso valore e questo ne troverà solo uno. La differenza nel loro impronta di memoria è evidente: l'int utilizza 4 byte, il numero intero utilizza 16 byte.SparseArray utilizza int come valore chiave.
Esempio di base con SparseArray
class Person {
String name;
public Person(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
final Person steve = new Person("Steve");
Person[] persons = new Person[] { new Person("John"), new Person("Gwen"), steve, new Person("Rob") };
int[] identifiers = new int[] {1234, 2345, 3456, 4567};
final SparseArray<Person> demo = new SparseArray<>();
// Mapping persons to identifiers.
for (int i = 0; i < persons.length; i++) {
demo.put(identifiers[i], persons[i]);
}
// Find the person with identifier 1234.
Person id1234 = demo.get(1234); // Returns John.
// Find the person with identifier 6410.
Person id6410 = demo.get(6410); // Returns null.
// Find the 3rd person.
Person third = demo.valueAt(3); // Returns Rob.
// Find the 42th person.
//Person fortysecond = demo.valueAt(42); // Throws ArrayIndexOutOfBoundsException.
// Remove the last person.
demo.removeAt(demo.size() - 1); // Rob removed.
// Remove the person with identifier 1234.
demo.delete(1234); // John removed.
// Find the index of Steve.
int indexOfSteve = demo.indexOfValue(steve);
// Find the identifier of Steve.
int identifierOfSteve = demo.keyAt(indexOfSteve);
