Por ejemplo, las imágenes de carga de la red de caché:
// Obtenga la memoria máxima asignada por la aplicación int maxMemory = (int) runtime.getRuntime (). MaxMemory (); // Obtener 1/5 de la memoria para usar cuando el tamaño de la memoria caché es int cachesize = maxMememory/5; // instantáneos lrucache lrucache = new lrucache <string, bitmap> (cachsize) {// El tamaño del método interno del tamaño de la memoria caché de cada imagen protegida intited sizeOf (clave de cadena, valor de map) {// llamado cada vez que el caché se almacena para que el sistema sea grande que la imagen de la imagen grande es // es equivalente a un espacio de tamaño para alquilar un espacio para el espacio de los recursos a los recursos a ser C. value.getByTecount (); }}; El código anterior generalmente se coloca en el método de inicialización
De hecho, la clase Lurcache puede entenderse como mapa de la clase de mapa. Hay métodos de poner y obtener
A continuación, llame y obtenga métodos para acceder a los recursos en caché
Agregar a Lurcache:
public void PutBitMaptocache (URL de cadena, mapas de bitmap) {if (getBitMapFromCache (url) == null) {// juzga si el caché actual existe lrucache.put (url, bitmap); }} Lurcache get: public bitmap getBitMap fromCache (string url) {return lrucache.get (url); // lrucache puede considerarse como un mapa} Llamar a los métodos de agregar y obtener los métodos anteriores puede almacenar en caché de los recursos, lo cual es bastante simple.
Pero tenga cuidado de que LruCache lruCache=new LruCache<String, Bitmap>(cachSize) solo pueda ser nuevo una vez, de lo contrario, diferentes objetos se almacenarán de manera diferente.
Adjunto con la clase Lrucache de Android
paquete android.util; import java.util.linkedhashmap; import java.util.map; /*** Un caché que contiene referencias fuertes a un número limitado de valores. Cada vez que se accede * un valor, se mueve a la cabeza de una cola. Cuando se agrega un valor * a un caché completo, el valor al final de esa cola se desalija y puede * volverse elegible para la recolección de basura. * El caché guarda una fuerte referencia para limitar el número de contenidos. Cada vez que se accede al artículo, el artículo se moverá hacia la cabeza de la cola. * Cuando se agrega un nuevo elemento cuando el caché está lleno, el elemento al final de la cola se reciclará. * <P> Si sus valores en caché tienen recursos que necesitan ser liberados explícitamente, * anular {@link #EntryRemoved}. * Si se debe calcular una fallas de caché a pedido de las claves correspondientes, * anular {@link #create}. Esto simplifica el código de llamada, lo que permite que * asuma que siempre se devolverá un valor, incluso cuando hay una falla de caché. * Si el elemento correspondiente a la clave se pierde, reescribe Create (). Esto simplifica el código de llamadas y siempre volverá incluso si se pierde. * <P> Por defecto, el tamaño del caché se mide en el número de entradas. Anular * {@link #sizeof} para dimensionar el caché en diferentes unidades. Por ejemplo, este caché * está limitado a 4MIB de mapas de bits: el tamaño de caché predeterminado es el número de elementos medidos, y el tamaño del caché se anula para calcular el tamaño * de diferentes elementos. * <pre> {@code * int Cachesize = 4 * 1024 * 1024; // 4mib * lrucache <string, bitmap> bitmapcache = new lrucache <string, bitmap> (cachesize) { * intisted sizeOf (tecla de cadena, valor de map) { * return.getByTecount (); *} *}} </pre> * * <p> Esta clase es Safe. Realice múltiples operaciones de caché atómicamente * sincronizando en el caché: <pre> {@code * sincronizado (cache) { * if (cache.get (key) == null) { * cache.put (key, valor); *} *}} </pre> * * <p> Esta clase no permite que NULL se use como clave o valor. Un valor de retorno * de NULL de {@link #get}, {@link #put} o {@link #Remove} es * inequívoco: la clave no estaba en el caché. * La clave o el valor es nulo * Cuando get (), put (), eliminar () el valor de retorno es nulo, el elemento correspondiente de la clave no está en el caché */ clase pública lrucache <k, v> {private final Linkedhashmap <k, v> map; /** Tamaño de este caché en unidades. No necesariamente el número de elementos. */ tamaño privado int; // El tamaño que se ha almacenado privado int maxsize; // El espacio de almacenamiento máximo especificado int PutCount; // El número de put private int createCount; // El número de veces de crear private int EvictionCount; // El número de veces de reciclado privado int int hitcount; // Número de hits private int MissCount; // Número de Lost/** * @param maxSize para cachés que no anulan {@link #sizeOf}, este es * el número máximo de entradas en el caché. Para todos los demás cachés, * esta es la suma máxima de los tamaños de las entradas en este caché. */ public lrucache (int maxSize) {if (maxsize <= 0) {tire nueva ilegalArgumentException ("maxSize <= 0"); } this.maxSize = maxSize; this.map = new Linkedhashmap <k, v> (0, 0.75f, verdadero); } /** * Devuelve el valor para {@Code Key} si existe en el caché o puede ser * creado por {@code #create}. Si se devolvió un valor, se mueve al * jefe de la cola. Esto devuelve nulo si un valor no se almacena en caché y no se puede * crear *. Devuelva el elemento correspondiente por clave, o cree una devolución del elemento correspondiente. El elemento correspondiente se moverá al cabezal de la cola, * si el valor del elemento no se almacena en caché o no se puede crear, devuelve nulo. */ public final v get (k key) {if (key == null) {throw new NullPointerException ("Key == NULL"); } V MapValue; sincronizado (this) {mapValue = map.get (clave); if (mapValue! = null) {hitcount ++; // presione return mapValue; } MissCount ++; // Lost} / * * intenta crear un valor. Esto puede llevar mucho tiempo, y el mapa * puede ser diferente cuando crea () regresa. Si se agregó un valor conflictivo * al mapa mientras crea () estaba funcionando, dejamos ese valor en * el mapa y liberamos el valor creado. * Si falta, intente crear un elemento */ v createValue = create (key); if (createValue == null) {return null; } sincronizado (this) {createCount ++; // create ++ mapValue = map.put (key, createValue); if (mapValue! = null) {// Hubo un conflicto tan deshacer que la última put // si hay un OldValue antes, deshace Put () map.put (Key, MapValue); } else {size += safeSizeOf (key, createValue); }} if (mapValue! = null) {EntryRemoved (false, clave, creationValue, mapValue); return mapValue; } else {Trimtosize (maxSize); return createdValue; }} /*** Caches {@code valor} para {@code key}. El valor se mueve a la cabeza de * la cola. * * @return El valor anterior asignado por {@code Key}. */ public final v put (k key, v valor) {if (key == null || valor == null) {throw new nullPointerException ("key == null || valor == null"); } V anterior; sincronizado (this) {PutCount ++; size += safeSizeOf (clave, valor); anterior = map.put (clave, valor); if (anterior! = null) {// El valor anterior devuelto es tamaño -= safeSizeOf (clave, anterior); }} if (anterior! = null) {entryRemoved (falso, clave, anterior, valor); } Trimtosize (maxSize); regresar anteriormente; } /*** @param maxSize el tamaño máximo del caché antes de regresar. Puede ser -1 * para desalojar incluso elementos de tamaño 0. * Clear Cache Space*/ private void Trimtosize (int maxSize) {while (true) {k key; V valor; SynChronized (this) {if (size <0 || (map.isEmpty () && size! = 0)) {tire nueva ilegalStateException (getClass (). getName () + ".sizeOf () está informando resultados inconsistentes!"); } if (size <= maxSize) {break; } Map.entry <k, v> toevict = map.eldest (); if (toevict == null) {break; } key = toevict.getKey (); valor = toevict.getValue (); map.remove (clave); tamaño -= safeSizeOf (clave, valor); Desvictivo COUNT ++; } entryRemoved (verdadero, clave, valor, nulo); }} /*** Elimina la entrada para {@code Key} si existe. * Elimine el elemento de caché correspondiente de la clave y devuelva el valor correspondiente * @return el valor anterior asignado por {@code Key}. */ public final V remove (k key) {if (key == null) {throle new NullPointerException ("Key == NULL"); } V anterior; sincronizado (this) {anterior = map.remove (clave); if (anterior! = null) {size -= safeSizeOf (clave, anterior); }} if (anterior! = null) {entryRemoved (falso, clave, anterior, nulo); } return anterior; } /*** pidió entradas que han sido desalojadas o eliminadas. Este método se invoca * cuando un valor se desalienta para hacer espacio, eliminado por una llamada a * {@link #Remove}, o reemplazada por una llamada a {@link #put}. La implementación predeterminada * no hace nada. * Llamado cuando el artículo se recicla o elimina. Cambie el método cuando el valor se recicla y libera el espacio de almacenamiento, se llama eliminar, o cuando se reemplaza el valor del elemento, la implementación predeterminada no hace nada. * <P> El método se llama sin sincronización: otros subprocesos pueden * acceder al caché mientras se ejecuta este método. * * @param desalojó verdadero si la entrada se está eliminando para hacer espacio, falso * Si la eliminación fue causada por un {@link #put} o {@link #Remove}. * Verdadero --- Ponga o elimine las causas * @param newValue el nuevo valor para {@code key}, si existe. Si no es nulo, * esta eliminación fue causada por un {@link #put}. De lo contrario, fue causado por * un desalojo o un {@link #remove}. * / protegido void entryremoved (desalojado booleano, k key, v OldValue, v NewValue) {} / *** Llamado después de un caché falla para calcular un valor para la clave correspondiente. * Devuelve el valor calculado o nulo si no se puede calcular ningún valor. La implementación * predeterminada devuelve nulo. * Cuando se pierde un elemento, se llamará, devolviendo el valor correspondiente calculado o nulo * <p> El método se llama sin sincronización: otros subprocesos pueden * acceder al caché mientras este método se está ejecutando. * * <p> Si existe un valor para {@code key} en el caché cuando este método * regresa, el valor creado se lanzará con {@link #Entryremoved} * y se divulgará. Esto puede ocurrir cuando múltiples subprocesos solicitan la misma clave * al mismo tiempo (causando que se creen múltiples valores), o cuando un * hilo llame {@link #put} mientras que otro está creando un valor para la misma clave *. */ Protected v create (k key) {return null; } private int safeSizeOf (k key, V value) {int result = sizeOf (clave, valor); if (resultado <0) {tirar nueva ilegalstateException ("tamaño negativo:" + key + "=" + valor); } resultado de retorno; } /** * Devuelve el tamaño de la entrada para {@code key} y {@code valor} en * unidades definidas por el usuario. La implementación predeterminada devuelve 1 para que ese tamaño * sea el número de entradas y el tamaño máximo es el número máximo de entradas. * Devuelve el tamaño del elemento definido por el usuario, el retorno predeterminado 1 representa el número de elementos, el tamaño máximo es el valor máximo del elemento* <p> El tamaño de una entrada no debe cambiar mientras está en el caché. */ protegido int sizeOf (k key, valor v) {return 1; } /*** Borre el caché, llamando {@link #EntryRemoved} en cada entrada eliminada. * Clare caché */ public final void savictall () {Trimtosize (-1); // -1 desalojará elementos de 0 tamaño} /** * Para cachés que no anulan {@link #sizeOf}, esto devuelve el número * de entradas en el caché. Para todos los demás cachés, esto devuelve la suma de * los tamaños de las entradas en este caché. */ public sincronized final int size () {return size; } /** * Para cachés que no anulan {@link #SizeOf}, esto devuelve el número máximo * de entradas en el caché. Para todos los demás cachés, esto devuelve la * suma máxima de los tamaños de las entradas en este caché. */ public sincronizado final int maxSize () {return maxSize; } /** * Devuelve el número de veces {@link #get} devolvió un valor que * ya estaba presente en el caché. */ public sincronizado final int hitcount () {return hitcount; } /** * Devuelve el número de veces {@link #get} devuelto nulo o requirió un nuevo valor * para crear. */ public sincronizado final int MissCount () {return MissCount; } /*** Devuelve el número de veces {@link #create (object)} devolvió un valor. */ public sincronizado final int createCount () {return createCount; } /*** Devuelve el número de veces {@link #put} se llamó. */ public sincronizado final int pontcount () {return PutCount; } /*** Devuelve el número de valores que han sido desalojados. */ public sincronizado final intscentCount () {return EvictionCount; } /** * Devuelve una copia del contenido actual del caché, ordenado del mínimo * recientemente accedido al acceso más recientemente. Devuelve una copia del caché actual, desde el menor acceso recientemente al que se accede más recientemente. Mapa final sincronizado público <k, v> snapshot () {return new Linkedhashmap <k, v> (map); } @Override public sincronizado String final toString () {int accesos = hitcount + misscount; int hitpercent = access! = 0? (100 * hitcount / accesos): 0; return string.Format ("lrucache [maxSize =%d, hits =%d, fisses =%d, hitRate =%d %%]", maxSize, hitcount, MissCount, hit porcent); }}