Par exemple, les images de chargement du réseau de cache:
// Obtenez la mémoire maximale allouée par l'application int maxMemory = (int) runtime.getRuntime (). MaxMemory (); // Obtenez 1/5 de la mémoire à utiliser lorsque la taille du cache est int cacheSize = maxMemory / 5; // Instant lrucache lrucache = new Lrucache <String, bitmap> (cachsize) {// la méthode interne Sizeof définit la taille du cache de chaque image protégé par l'image (clé de chaîne, valeur bitmap) {// appelé chaque fois que le cache est stocké pour indiquer au système la taille de l'image du cache // il est équivalent à la taille de l'alocation value.getByteCount (); }}; Le code ci-dessus est généralement placé dans la méthode d'initialisation
En fait, la classe Lurcache peut être comprise comme une carte de classe de carte. Il y a des méthodes de put
Ensuite, appelez et obtenez des méthodes pour accéder aux ressources mises en cache
Add de Lurcache:
public void putBitMaptOCache (URL de chaîne, bitmap bitmap) {if (getBitmapFromCache (url) == null) {// juge si le cache actuel existe lrucache.put (url, bitmap); }} LurCache get: public bitmap getBitmap FromCache (URL de chaîne) {return lrucache.get (url); // lrucache peut être considéré comme une carte} Appeler les méthodes d'ajout et d'obtention ci-dessus peut mettre en cache des ressources, ce qui est assez simple.
Mais soyez prudent que LruCache lruCache=new LruCache<String, Bitmap>(cachSize) ne peut être nouveau qu'une fois, sinon différents objets seront mis en cache différemment.
Joints avec la classe Lrucache d'Android
package Android.util; import java.util.linkedhashmap; importation java.util.map; / ** * Un cache qui contient de fortes références à un nombre limité de valeurs. Chaque fois que * une valeur est accessible, il est déplacé vers la tête d'une file d'attente. Lorsqu'une valeur est * ajoutée à un cache complet, la valeur à la fin de cette file d'attente est expulsée et peut * devenir éligible à la collecte des ordures. * Cache enregistre une forte référence pour limiter le nombre de contenus. Chaque fois que l'article est accessible, l'élément se déplacera vers la tête de la file d'attente. * Lorsqu'un nouvel élément est ajouté lorsque le cache est plein, l'élément à la fin de la file d'attente sera recyclé. * <p> Si vos valeurs en cache contiennent des ressources qui doivent être explicitement libérées, * Override {@Link #EntryReMoved}. * Si un manque de cache doit être calculé à la demande pour les touches correspondantes, * Override {@Link #create}. Cela simplifie le code d'appel, lui permettant de * supposer qu'une valeur sera toujours renvoyée, même lorsqu'il y a un cache. * Si l'élément correspondant à la clé est perdu, réécrivez Create (). Cela simplifie le code d'appel et reviendra toujours même s'il est perdu. * <p> Par défaut, la taille du cache est mesurée dans le nombre d'entrées. Override * {@link #sizeof} pour dimensionner le cache en différentes unités. Par exemple, ce cache * est limité à 4mib de bitmaps: la taille du cache par défaut est le nombre d'éléments mesurés et la taille du cache est remplacée pour calculer la taille * de différents éléments. * <pre> {@code * int cachesize = 4 * 1024 * 1024; // 4MIB * LRUCACHE <String, Bitmap> BitmapCache = new LRUCACHE <String, Bitmap> (CacheSize) {* Protected int sizeof (String Key, Bitmap Value) {* return value.getByteCount (); *} *}} </ pre> * * <p> Cette classe est thread-safe. Effectuer plusieurs opérations de cache atomiquement par * synchronisant sur le cache: <pre> {@code * synchronisé (cache) {* if (cache.get (key) == null) {* cache.put (key, value); *} *}} </ pre> * * <p> Cette classe ne permet pas à Null d'être utilisé comme clé ou valeur. Une valeur de retour * de null de {@link #get}, {@link #put} ou {@link #remove} est * sans ambiguïté: la clé n'était pas dans le cache. * la touche ou la valeur est nul * Lorsque get (), put (), la valeur de retour supprime () est nul, l'élément correspondant de la clé n'est pas dans le cache * / classe publique lrucache <k, v> {private final linkedhashmap <k, v> map; / ** Taille de ce cache en unités. Pas nécessairement le nombre d'éléments. * / Taille int privée; // la taille qui a été stockée private int maxsize; // l'espace de stockage maximum spécifié private int putCount; // le nombre de put private int createCount; // le nombre de fois de création de private int EpictionCount; // le nombre de fois de private recyclé int int int hitCount; // Nombre de succès private int missCount; // Nombre de perdus / ** * @param maxsize pour les caches qui ne remplacent pas {@link #sizeof}, c'est * le nombre maximum d'entrées dans le cache. Pour tous les autres caches, * Il s'agit de la somme maximale des tailles des entrées dans ce cache. * / public lrucache (int maxSize) {if (maxSize <= 0) {lancez new illégalArgumentException ("maxSize <= 0"); } this.maxsize = maxSize; this.map = new LinkedHashmap <k, v> (0, 0,75f, true); } / ** * Renvoie la valeur pour {@code key} s'il existe dans le cache ou peut être * créé par {@code #create}. Si une valeur a été renvoyée, elle est déplacée vers la tête * de la file d'attente. Cela renvoie NULL si une valeur n'est pas mise en cache et ne peut pas être créée. Renvoyez l'élément correspondant par clé ou créez un renvoyer l'élément correspondant. L'élément correspondant se déplacera vers la tête de la file d'attente, * Si la valeur de l'élément n'est pas mise en cache ou ne peut pas être créée, renvoyez NULL. * / public final v get (k key) {if (key == null) {throw new nullpointerException ("key == null"); } V MapValue; synchronisé (this) {mapValue = map.get (key); if (mapValue! = null) {hitCount ++; // Appuyez sur RETOUR MAPVALUE; } missCount ++; // perdu} / * * Essayez de créer une valeur. Cela peut prendre beaucoup de temps, et la carte * peut être différente lorsque Create () revient. Si une valeur contradictoire était * ajoutée à la carte pendant que Create () fonctionnait, nous laissons cette valeur dans * la carte et libérons la valeur créée. * S'il manque, essayez de créer un élément * / v créé Value = Create (key); if (CreatedValue == null) {return null; } synchronisé (this) {createCount ++; // Create ++ mapValue = map.put (key, créeyValue); if (mapValue! = null) {// Il y a eu un conflit si annulant que le dernier a mis // s'il y a un OldValue avant, undo put () map.put (key, mapValue); } else {size + = safesizeOf (key, créeyValue); }} if (mapValue! = null) {EntryReMoved (false, key, createdValue, mapValue); retour mapValue; } else {TrimToSize (maxSize); return createdValue; }} / ** * Caches {@Code Value} pour {@code key}. La valeur est déplacée vers la tête de * la file d'attente. * * @return la valeur précédente mappée par {@code key}. * / public final v put (k key, v Value) {if (key == null || value == null) {throw new NullPointerException ("key == null || value == null"); } V Précédent; synchronisé (this) {putCount ++; Size + = SafeSizeOf (clé, valeur); Primed = map.put (clé, valeur); if (précédent! = null) {// La valeur précédente renvoyée est size - = safesizeOf (key, précédent); }} if (précédent! = null) {entryReMoved (false, key, précédent, valeur); } trimToSize (maxSize); retour précédent; } / ** * @param maxSize la taille maximale du cache avant de revenir. Peut être -1 * pour expulser même les éléments de taille 0. * Espace de cache transparent * / private void trimToSize (int maxSize) {while (true) {k key; V valeur v; synchronisé (this) {if (size <0 || (map.isempty () && size! = 0)) {Throw new illégalStateException (getClass (). getName () + ".sizeof () rapporte des résultats incohérents!"); } if (size <= maxSize) {break; } Map.entry <k, v> toevict = map.eldest (); if (toeVict == null) {break; } key = toevict.getKey (); valeur = toevict.getValue (); Map.Remove (clé); Size - = SafeSizeOf (clé, valeur); EvictionCount ++; } EntryReMoved (true, key, valeur, null); }} / ** * supprime l'entrée pour {@code key} s'il existe. * Supprimez l'élément de cache correspondant de la clé et renvoyez la valeur correspondante * @return la valeur précédente mappée par {@code key}. * / public final v Suppor (k key) {if (key == null) {throw new nullpointerException ("key == null"); } V Précédent; synchronisé (this) {PREMER = map.Remove (key); if (précédent! = null) {size - = safesizeOf (key, précédent); }} if (précédent! = null) {EntryReMoved (false, key, précédent, null); } retour précédent; } / ** * a appelé les entrées qui ont été expulsées ou supprimées. Cette méthode est * invoquée lorsqu'une valeur est expulsée pour faire de l'espace, supprimée par un appel à * {@link #remove}, ou remplacé par un appel à {@link #put}. L'implémentation par défaut * ne fait rien. * Appelé lorsque l'élément est recyclé ou supprimé. Modifiez la méthode lorsque la valeur est recyclée et libère l'espace de stockage, il est appelé supprimer, ou lorsque la valeur de l'élément est remplacée, l'implémentation par défaut ne fait rien. * <p> La méthode est appelée sans synchronisation: d'autres threads peuvent * accéder au cache pendant que cette méthode s'exécute. * * @param a expulsé True si l'entrée est supprimée pour faire de la place, FAUX * Si la suppression a été causée par un {@link #put} ou {@link #remove}. * true --- Put ou supprime les causes * @param newValue la nouvelle valeur pour {@code key}, si elle existe. Si non nulle, * cette suppression a été causée par un {@link #put}. Sinon, il a été causé par * une expulsion ou un {@link #remove}. * / Protected void EntryReMoved (booléen expulsé, k key, v oldvalue, v newValue) {} / ** * appelé après un cache raté pour calculer une valeur pour la clé correspondante. * Renvoie la valeur calculée ou NULL si aucune valeur ne peut être calculée. L'implémentation * par défaut renvoie null. * Lorsqu'un élément est perdu, il sera appelé, renvoyant la valeur correspondante calculée ou NULL * <p> La méthode est appelée sans synchronisation: d'autres threads peuvent * accéder au cache pendant que cette méthode s'exécute. * * <p> Si une valeur pour {@code key} existe dans le cache lorsque cette méthode * renvoie, la valeur créée sera publiée avec {@Link #EntryReMoved} * et divulguée. Cela peut se produire lorsque plusieurs threads demandent la même touche * en même temps (provoquant la création de plusieurs valeurs), ou quand un * thread appelle {@link #put} tandis qu'une autre crée une valeur pour la même * touche. * / Protected v Create (k key) {return null; } private int safeSizeOf (k key, v Value) {int result = sizeof (key, valeur); if (result <0) {Throw New illégalStateException ("Taille négative:" + key + "=" + valeur); } Retour Résultat; } / ** * Renvoie la taille de l'entrée pour {@code key} et {@Code Value} dans * Unités définies par l'utilisateur. L'implémentation par défaut renvoie 1 de sorte que cette taille * est le nombre d'entrées et la taille maximale est le nombre maximum d'entrées. * Retour de la taille de l'élément défini par l'utilisateur, le retour de défaut 1 représente le nombre d'éléments, la taille maximale est la valeur maximale de l'élément * <p> La taille d'une entrée ne doit pas changer pendant le cache. * / Int size protégé (k key, vale v) {return 1; } / ** * Effacer le cache, appelant {@link #EntryReMoved} sur chaque entrée supprimée. * Clear Cache * / public final void evictall () {TrimToSize (-1); // -1 expulsera les éléments de taille 0} / ** * pour les caches qui ne remplacent pas {@link #sizeof}, cela renvoie le nombre * des entrées dans le cache. Pour tous les autres caches, cela renvoie la somme de * les tailles des entrées dans ce cache. * / public synchronisé final int size () {return size; } / ** * Pour les caches qui ne remplacent pas {@link #sizeof}, cela renvoie le nombre maximum * des entrées dans le cache. Pour tous les autres caches, cela renvoie la * somme maximale des tailles des entrées dans ce cache. * / public synchronisé final int maxsize () {return maxSize; } / ** * Renvoie le nombre de fois {@link #get} a renvoyé une valeur qui était * déjà présente dans le cache. * / public synchronisé final int hitCount () {return hitCount; } / ** * Renvoie le nombre de fois {@link #get} renvoyé null ou requis une nouvelle * valeur à créer. * / public synchronisé final int missCount () {return missCount; } / ** * Renvoie le nombre de fois {@link #create (objet)} a renvoyé une valeur. * / public synchronisé final int createCount () {return CreateCount; } / ** * Renvoie le nombre de fois {@link #put} a été appelé. * / public synchronisé final int putCount () {return putCount; } / ** * Renvoie le nombre de valeurs qui ont été expulsées. * / public synchronisé final int epictionCount () {return epictionCount; } / ** * Renvoie une copie du contenu actuel du cache, commandé au moins * récemment accessible à la récente. Renvoie une copie du cache actuel, des moins récemment accessibles au plus récemment consulté. Map final synchronisé public <k, v> snapshot () {return new LinkedHashmap <k, v> (map); } @Override public synchronisé final String toString () {int accorde = hitCount + missCount; int hitpercent = accès! = 0? (100 * HitCount / Accesss): 0; return String.Format ("LRUCACHE [maxSize =% D, Hits =% D, miss =% d, hitrate =% d %%]", maxsize, hitCount, missCount, hitpercent); }}