Por exemplo, cache de imagens de carregamento de rede:
// obtém a memória máxima alocada pelo aplicativo int maxMemory = (int) runtime.getRuntime (). Maxmemory (); // Obtenha 1/5 da memória para usar quando o tamanho do cache estiver int em cachesize = maxMemory/5; // instantâneo lrucache lrucache = new lrucache <string, bitmap> (cachsize) {// O tamanho do método interno de defina o tamanho do cache de cada imagem protegida Int sizeof (tecla de string, valor de bitmap) {// chamado Everyth tlesing O cache é armazenado para dizer ao sistema que o tamanho da imagem do cache é // é o equivalente a todo o space para o tamanho da imagem do sistema // é // é chamado para todos os recursos, o tamanho do sistema é o tamanho da imagem de cache) {// é o que é chamado para todos os recursos do sistema, é // é o que é o tamanho da imagem de cache. value.getByteCount (); }}; O código acima é geralmente colocado no método de inicialização
De fato, a classe Lurcache pode ser entendida como mapa de classe do mapa. Existem métodos de venda e obtenção
Em seguida, ligue para os métodos Put and Get para acessar os recursos em cache
Adicionar de Lurcache:
public void putbitMaptocache (String URL, bitmap bitmap) {if (getBitMapFromCache (url) == null) {// julga se o cache atual existe lrucache.put (url, bitmap); }} Lurcache get: public bitmap getBitmap fromcache (string url) {return lrucache.get (url); // lrucache pode ser considerado como um mapa} Chamar os métodos de Adicionar e Get de Adicionar e Get acima podem cache os recursos, o que é bastante simples.
Mas tenha cuidado para que LruCache lruCache=new LruCache<String, Bitmap>(cachSize) possa ser novo apenas uma vez, caso contrário, objetos diferentes serão armazenados em cache de maneira diferente.
Anexado com a classe Lrucache do Android
pacote Android.util; importar java.util.linkedhashmap; importar java.util.map; /*** Um cache que mantém fortes referências a um número limitado de valores. Cada vez * um valor é acessado, ele é movido para a cabeça de uma fila. Quando um valor é * adicionado a um cache completo, o valor no final dessa fila é despejado e pode se tornar elegível para a coleta de lixo. * O cache salva uma forte referência para limitar o número de conteúdo. Sempre que o item for acessado, o item se moverá para a cabeça da fila. * Quando um novo item é adicionado quando o cache estiver cheio, o item no final da fila será reciclado. * <p> Se seus valores em cache mantêm recursos que precisam ser lançados explicitamente, * substituir {@link #entryRemoved}. * Se uma falta de cache deve ser calculada sob demanda pelas teclas correspondentes, * substitua {@link #create}. Isso simplifica o código de chamada, permitindo que ele * assuma que um valor sempre será retornado, mesmo quando houver uma falta de cache. * Se o item correspondente à chave for perdido, reescreva Crie (). Isso simplifica o código de chamada e sempre retornará mesmo que seja perdido. * <p> Por padrão, o tamanho do cache é medido no número de entradas. Substitua * {@link #sizeof} para dimensionar o cache em diferentes unidades. Por exemplo, esse cache * é limitado a 4mib de bitmaps: o tamanho do cache padrão é o número de itens medidos e o tamanho do cache é substituído para calcular o tamanho * de itens diferentes. * <pre> {@code * int cachesize = 4 * 1024 * 1024; // 4mib * lrucache <string, bitmap> bitmapcache = new lrucache <string, bitmap> (cacheize) { * protegido int sizeof (chave de string, bitmap value) { * return value.getByteCount (); *} *}} </pre> * * <p> Esta classe é segura de threads. Execute várias operações de cache atomicamente, sincronizando no cache: <pre> {@code * sincronizado (cache) { * if (cache.get (key) == null) { * cache.put (chave, value); *} *}} </pre> * * <p> Esta classe não permite que o NULL seja usado como chave ou valor. Um valor de retorno * de null de {@link #get}, {@link #put} ou {@link #remove} é * inequívoco: a chave não estava no cache. * tecla ou valor é nulo * quando get (), put (), remover () o valor de retorno é nulo, o item correspondente da chave não está no cache */ classe pública lrucache <k, v> {private final LinkedHashmap <k, v> mapa; /** Tamanho deste cache nas unidades. Não necessariamente o número de elementos. */ tamanho privado int; // o tamanho que foi armazenado privado int maxsize; // o espaço de armazenamento máximo especificado privado int putcount; // o número de Put Private int createCount; // o número de vezes de criar private int evictionCount; // o número de vezes de private Int int int int int hitcount; // Número de hits Private Int MissCount; // Número de perdidos/** * @param maxsize para caches que não substituem {@link #sizeof}, este é * o número máximo de entradas no cache. Para todos os outros caches, * esta é a soma máxima dos tamanhos das entradas neste cache. */ public lrucache (int maxSize) {if (maxsize <= 0) {lança novo ilegalargumentException ("maxSize <= 0"); } this.maxSize = maxSize; this.map = new LinkedHashmap <k, v> (0, 0,75f, true); } /** * Retorna o valor para {@Code Key} se existir no cache ou pode ser * criado por {@code #create}. Se um valor foi retornado, ele será movido para a cabeça * da fila. Isso retorna nulo se um valor não for armazenado em cache e não puder * ser criado. Retorne o item correspondente por chave ou crie um retorno do item correspondente. O item correspondente se moverá para a cabeça da fila, * se o valor do item não for armazenado em cache ou não puder ser criado, retorne nulo. */ public final V get (K key) {if (key == null) {lança new NullPointerException ("key == null"); } V mapValue; sincronizado (this) {mapValue = map.get (key); if (mapValue! = null) {hitcount ++; // Hit Return MapValue; } missCount ++; // perdido} / * * Tente criar um valor. Isso pode levar muito tempo, e o mapa * pode ser diferente ao criar () retornar. Se um valor conflitante foi * adicionado ao mapa enquanto Create () estava funcionando, deixamos esse valor no * mapa e liberamos o valor criado. * Se estiver faltando, tente criar um item */ v criateValue = create (key); if (CreatedValue == NULL) {return null; } sincronizada (this) {createCount ++; // create ++ mapValue = map.put (chave, criada); if (mapValue! = null) {// houve um conflito, então desfazer o último put // se houver um valor antigo antes dele, desponha put () map.put (chave, mapValue); } else {size += safesizeof (chave, criou um valor); }} if (mapValue! = NULL) {EntryRemoved (false, chave, criadaValue, mapValue); retornar mapValue; } else {Trimtosize (maxSize); return criatedvalue; }} /*** cache {@code value} para {@code chave}. O valor é movido para a cabeça da * fila. * * @RETURN O valor anterior mapeado por {@code chave}. */ public final V put (K -Key, V Value) {if (key == null || value == null) {tiro new nullPointerException ("key == null || value == null"); } V anterior; sincronizado (this) {putcount ++; tamanho += cofesizeof (chave, valor); anterior = map.put (chave, valor); if (anterior! }} if (anterior! = null) {EntryRemoved (false, chave, anterior, valor); } trimtosize (maxSize); retornar anterior; } /*** @param maxsize o tamanho máximo do cache antes de retornar. Pode ser -1 * para despejar até elementos de tamanho 0. * Espaço de cache limpo*/ private void Trimtosize (int maxSize) {while (true) {k key; Valor V; sincronizado (this) {if (size <0 || (map.isEmpty () && size! = 0)) {tire new ilegalStateException (getClass (). getName () + ".sizeof () está relatando resultados inconsistentes!"); } if (size <= maxSize) {break; } Map.entry <k, v> toevict = map.eldest (); if (toevict == null) {break; } key = toevict.getKey (); value = ToEvict.getValue (); map.remove (chave); tamanho -= cofesizeof (chave, valor); despettionCount ++; } EntryRemoved (true, chave, valor, nulo); }} /*** Remove a entrada para {@Code Key} se existir. * Exclua o item de cache correspondente da tecla e retorne o valor correspondente * @return O valor anterior mapeado por {@code chave}. */ public final V remover (K -key) {if (key == null) {lança new nullPointerException ("key == null"); } V anterior; sincronizado (this) {anterior = map.remove (chave); if (anterior! = null) {size -= safesizeof (chave, anterior); }} if (anterior! = null) {EntryRemoved (false, chave, anterior, nulo); } retornar anterior; } /*** chamado para entradas que foram despejadas ou removidas. Este método é * chamado quando um valor é despejado para abrir espaço, removido por uma chamada para * {@link #remove} ou substituído por uma chamada para {@link #put}. A implementação padrão * não faz nada. * Chamado quando o item é reciclado ou excluído. Altere o método quando o valor for reciclado e libera o espaço de armazenamento, é chamado de remoção ou quando o valor do item é substituído, a implementação padrão não faz nada. * <p> O método é chamado sem sincronização: outros threads podem * acessar o cache enquanto esse método está executando. * * @param despejado true se a entrada estiver sendo removida para abrir espaço, false * se a remoção foi causada por um {@link #put} ou {@link #remove}. * true --- colocar ou remover causas * @param newValue o novo valor para {@code}}, se existir. Se não nulo, * essa remoção foi causada por um {@link #put}. Caso contrário, foi causado por * um despejo ou um {@link #remove}. * / Protegido void EntryRemoved (despejo booleano, K Key, V OldValue, V NewValue) {} / *** Chamado após um cache perder para calcular um valor para a chave correspondente. * Retorna o valor calculado ou nulo se nenhum valor puder ser calculado. A implementação * padrão retorna nulo. * Quando um item for perdido, ele será chamado, retornando o valor correspondente calculado ou nulo * <p> O método é chamado sem sincronização: outros threads podem * acessar o cache enquanto esse método está executando. * * <p> Se um valor para {@code key} existir no cache quando esse método * retornar, o valor criado será lançado com {@link #entryRemoved} * e divulgado. Isso pode ocorrer quando vários threads solicitam a mesma chave * ao mesmo tempo (causando vários valores a serem criados) ou quando um * thread chama {@link #put} enquanto outro está criando um valor para a mesma chave *. */ protegido V Create (K key) {return null; } private int safesizeOf (K -Key, V valor) {int resultado = sizeof (chave, valor); if (resultado <0) {lança new ilegalStateException ("Tamanho negativo:" + key + "=" + valor); } resultado de retorno; } /** * Retorna o tamanho da entrada para {@Code Key} e {@code value} em * unidades definidas pelo usuário. A implementação padrão retorna 1 para que o tamanho * seja o número de entradas e o tamanho máximo é o número máximo de entradas. * Retorne o tamanho do item definido pelo usuário, o retorno padrão 1 representa o número de itens, o tamanho máximo é o valor máximo do item* <P> O tamanho de uma entrada não deve alterar enquanto estiver no cache. */ protegido Int sizeof (Key k, V valor) {return 1; } /*** Limpe o cache, chamando {@link #entryRemoved} em cada entrada removida. * Cache claro */ public final void despetall () {Trimtosize (-1); // -1 despejar elementos de tamanho 0} /** * Para caches que não substituem {@link #sizeof}, isso retorna o número * de entradas no cache. Para todos os outros caches, isso retorna a soma dos tamanhos das entradas neste cache. */ public sincronizado final int size () {Tamanho do retorno; } /** * Para caches que não substituem {@link #sizeof}, isso retorna o número máximo * de entradas no cache. Para todos os outros caches, isso retorna a soma máxima dos tamanhos das entradas neste cache. */ public sincronizado final int maxsize () {return maxSize; } /** * Retorna o número de vezes {@link #get} retornou um valor que já estava * presente no cache. */ public sincronizado final int hitcount () {return HitCount; } /** * Retorna o número de vezes {@link #get} retornou nulo ou exigiu um novo valor * a ser criado. */ public sincronizado final int missCount () {return missCount; } /*** Retorna o número de vezes {@link #Create (Object)} retornou um valor. */ public sincronizado final int createCount () {return createCount; } /*** Retorna o número de vezes {@link #put} foi chamado. */ public sincronizado final int putCount () {return putcount; } /*** Retorna o número de valores que foram despejados. */ public sincronizado Final Int despetctionCount () {return despettionCount; } /** * Retorna uma cópia do conteúdo atual do cache, ordenado pelo menos * acessado recentemente ao mais recentemente acessado. Retorna uma cópia do cache atual, desde os menos acessados recentemente para acessados mais recentemente. public sincronizado mapa final <k, v> snapshot () {return new LinkedHashmap <k, v> (mapa); } @Override Public sincronizado Final String ToString () {int Accesses = HitCount + MissCount; int hitpercent = accessos! = 0? (100 * HitCount / Accesses): 0; return string.format ("lrucache [maxsize =%d, hits =%d, misses =%d, hitrate =%d %%]", maxsize, hitcount, misscount, hitpercent); }}