Android
Comment utiliser SparseArray
Recherche…
Introduction
Un SparseArray est une alternative à une Map . Une Map nécessite que ses clés soient des objets. Le phénomène de la sélection automatique se produit lorsque nous voulons utiliser une valeur primitive int comme clé. Le compilateur convertit automatiquement les valeurs primitives en leurs types encadrés (par exemple int à Integer ). La différence de mémoire est notable: int utilise 4 octets, Integer utilise 16 octets. Un SparseArray utilise int comme valeur de clé.
Remarques
Avantage :
- Moins d’utilisation de la mémoire (à cause des clés primitives).
- Pas de boxe automatique.
Désavantage :
- SparseArray utilise la recherche binaire pour trouver la valeur (O (log n)), donc ce n'est peut-être pas la meilleure solution si vous devez travailler avec un grand nombre d'éléments (utilisez HashMap).
Il existe plusieurs variantes de la famille comme: -SparseArray <Integer, Object> -SparseBooleanArray <Entier, Booléen> -SparseIntArray <Entier, Entier> -SparseLongArray <Entier, Long> -LongSparseArray <Long, Objet> -LongSparseLongArray <Long, Long >
Opérations SparseArray
Ajout de l'élément - put (int, x): Ajoute un mappage de la clé spécifiée à la valeur spécifiée, remplaçant le précédent mappage de la clé spécifiée s'il y en avait une. - append (int, x): place une paire clé / valeur dans le tableau, en optimisant le cas où la clé est supérieure à toutes les clés existantes du tableau. Vous devez utiliser append () en cas de clés séquentielles pour optimiser les performances. Sinon, put () va bien.
Élément remove - delete (int): Supprime le mappage de la clé spécifiée, le cas échéant. - removeAt (int): Supprime le mappage à l'index donné. - removeAtRange (int, int): Supprime une plage de mappages en tant que lot.
access element - get (int): Obtient l'int intéré à partir de la clé spécifiée, ou 0 si aucun mappage n'a été effectué. - get (int, E): Obtient l'int mappé depuis la clé spécifiée ou la valeur spécifiée si aucun mappage n'a été effectué. - valueAt (int): Étant donné un index compris dans la plage 0 ... size () - 1, renvoie la valeur du mappage valeur-clé indexth stocké par SparseIntArray. Les indices sont classés par ordre croissant.
index / key search - keyAt (int): Étant donné un index compris entre 0 et size (), renvoie la clé du mappage index-valeur indexée stocké par SparseIntArray. Les indices sont classés par ordre croissant. - valueAt (int): Étant donné un index compris dans la plage 0 ... size () - 1, renvoie la valeur du mappage valeur-clé indexth stocké par SparseIntArray. Les indices sont classés par ordre croissant. - indexOfKey (int): renvoie l'index pour lequel keyAt (int) renverrait la clé spécifiée ou un nombre négatif si la clé spécifiée n'est pas mappée. - indexOfValue (E): renvoie un index pour lequel valueAt (int) renverrait la clé spécifiée ou un nombre négatif si aucune clé ne correspond à la valeur spécifiée. Attention, il s'agit d'une recherche linéaire, contrairement aux recherches par clé, et que plusieurs clés peuvent être mappées à la même valeur et que celle-ci n'en trouvera qu'une. La différence de leur empreinte mémoire est notable: l’int utilise 4 octets, l’Integer utilise 16 octets.
Exemple basique utilisant 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);