SparseArray, vérifiez si la clé existe

J'ai été mise en œuvre d'une mémoire cache des bitmaps à l'aide d'un HashMap<Integer, Bitmap> et a reçu l'avertissement suivant dans Eclipse:

Utiliser de nouvelles SparseArray(...) à la place pour de meilleures performances.

Je n'ai jamais entendu parler de cette classe avant, mais de l'examiner, il ne semble pas avoir un containsKey() méthode dont j'ai été l'appelant sur la récupération d'une image Bitmap à partir du cache de vérifier s'il existe dans le cache, et si ça ne marche pas, puis l'ajouter.

Toutes les idées sur la meilleure façon de vérifier si la clé existe déjà?

Je suppose que je pourrais modifier le code pour utiliser cette surcharge et de vérifier la valeur null?

Bitmap bitmap = cache.get(key, null);
InformationsquelleAutor magritte | 2012-09-15
  1. 45

    Vous pouvez utiliser:

    Bitmap bitmap = cache.get(key, null);

    Mais de comprendre que c'est le même que get(clé):

    Bitmap bitmap = cache.get(key);

    La meilleure façon d'utiliser get(key, default) est de fournir un générique par défaut les cas, quelque chose est un substitut valable lorsque la clé n'est pas trouvée.

    Mais il n'y a aucune bonne raison de ne pas utiliser if(get(key) != null) comme un remplacement rapide pour contains().

    • Merci Sam, bonne place sur la surcharge de travail, je suis allé avec votre suggestion de remplacer uniquement avec des si (get(clé) != null).
    InformationsquelleAutor Sam
  2. 30

    Donc votre valeur peut être nulle dans diverses situations, je vous suggère d'utiliserindexOfKey(int key)
    Voici la indexOfKey(int key) de référence.

    Puis il suffit de vérifier simplement négative de la valeur de retour

    if(mySparseArray.indexOfKey(int) < 0) {
   //Item does not exist. Do something relevant 
}
    • Est-ce mieux/pire que de simplement en utilisant .get?
    • .get(int) est O(1) parce que c'est la vérification de la sous-jacentes tableau directement. indexOf(int) est O(log(n)), car il n'binaire de recherche pour trouver le bon indice
    • Faux! le int dans get(int) n'est pas un indice, c'est une clé. Par conséquent, il n'est pas O(1). Les deux get(int) et indexOfKey(int) ont la même complexité O(log(n)), on renvoie la valeur de la position si trouvé, null sinon, les autres ne renvoie l'index si trouvé, une valeur négative sinon.
    • Vrai, à la fois get(int) et indexOfKey(int) binaires de recherche. Mon erreur.
    InformationsquelleAutor Alex
  3. 1

    Citant la documentation.

    SparseArrays carte entiers à des Objets. Contrairement à un tableau normal d'Objets, il peut y avoir des lacunes dans les indices. Il est destiné à être plus efficace que d'utiliser une table de hachage à la carte Entiers à des Objets.

    Vous pouvez utiliser get(int) qui permettrait également de retourner la valeur null si la clé n'est pas trouvée. Comme;

    Bitmap bitmap = cache.get(clé);

    • La clé peut avoir la valeur null, dans ce cas, avec votre code, vous ne serez pas en mesure de déterminer si la clé existe ou pas. c'est à dire si la clé n'existe pas, il va retourner la valeur null et si la clé a la valeur null, il va retourner la valeur null trop. indexOfKey doit être l'utilisateur dans ce cas (Voir Alex réponse)
    • assez vieille réponse et ce que vous suggérez est je suppose que via les nouvelles api. Toutefois réponse à votre commentaire, int primitive ne peut pas être null.
    • Je ne comprends pas comment le fait que les primitifs ne peut pas être null liées à mon commentaire. BTW, indexOfKey a été introduit dans l'API 1.
    • ok, je vois ce que tu veux dire maintenant, mais je pense que la question n'était pas vraiment sur les valeurs null. Ou qui a été de mon point de vue.
    • chose est sparsearray n'est pas censé être une carte. C'est un tableau, très long. Comme tableau normal, vous devriez obtenir une valeur null ou de référence. Si vous avez besoin de vérifier l'existance de touches, puis peut-être vous avez besoin d'une carte non un tableau. Je pense que c'est pourquoi Alex réponse n'est pas pertinente.
    • peut avoir la valeur null" -> "clé de carte à valeur null" je suppose que c'est pourquoi je n'ai pas eu la première fois.

    InformationsquelleAutor auselen
  4. 1

    Passe par la mise en œuvre de SparseArray il semble contre-intuitif que cela peut avoir de meilleures performances (temps de complexité) que HashMap (autres que les bas de l'espace-exigence qui fait sens pour un environnement mobile) depuis le get() membre de SparseArray utilise les binaires de recherche (O(log N)), alors que pour la table de hachage utilise le tableau d'indexation(O(1)).

    Fournir la méthode get() de la mise en œuvre pour les deux classes (as-is):

    public V get(Object key) { //for HashMap
    if (key == null)
        return getForNullKey();
    int hash = hash(key.hashCode());
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
            e != null;
            e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
            return e.value;
    }
    return null;
}

public E get(int key, E valueIfKeyNotFound) {  //for SparseArray
    int i = binarySearch(mKeys, 0, mSize, key);

    if (i < 0 || mValues[i] == DELETED) {
        return valueIfKeyNotFound;
    } else {
        return (E) mValues[i];
    }
}

    quant à l'utilisation indexOfKey(clé) < 0 ou get(clé) == null pour vérifier l'existence d'une clé dans un SparseArray, tout est ok, puisque à la fois utiliser les binaires de recherche-dessous.

    public int indexOfKey(int key) {  //for SparseArray
    if (mGarbage) {
        gc();
    }

    return binarySearch(mKeys, 0, mSize, key);
}
    • Je ne comprends pas où la connexion à partir de votre reponse aux questions posees.
    InformationsquelleAutor neel
  5. 0

    De multiples façons:

    1. Si vous souhaitez utiliser la valeur associée à la clé de toute façon, vous pouvez utiliser get() :

      val sparseArray = SparseArray<String>()
val someKey = 123
val someValue: String? = sparseArray[someKey]
if(someValue!=null){
    //do something
}

    Noter que contrairement à ce que l'IDE pense, il peut être nulle, ce qui est pourquoi j'ai ajouté ? .

    1. si vous voulez juste pour vérifier si elle existe, vous pouvez utiliser indexOfKey(key) >= 0

    2. Si vous n'aimez pas la-dessus, et que vous voulez un plus lisible option, vous pouvez utiliser containsKey de la ktx-collection de dépendance:

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

    Utilisation:

        val sparseArray = SparseArray<String>()
    val someKey = 123
    if (sparseArray.containsKey(someKey)) {
        //do something
    }
    InformationsquelleAutor android developer