Zum Beispiel das Cache -Netzwerk laden Bilder:
// Erhalten Sie den maximalen Speicher, der von der Anwendung int maxmemory = (int) runTime.getRuntime (). MaxMemory () zugewiesen wird; // Erhalten Sie 1/5 des Speichers, wenn die Cache -Größe int cachesize = maxMemory/5 ist; // Instant Lrucache lrucache = new lrucache <string, bitmap> (cachsize) {// interne Methodengröße von der Cache -Größe jedes Bild -geschützten Int -Größe (String -Schlüssel, Bitmap -Wert) {// Aufgerufen value.getByTeCount (); }}; Der obige Code wird normalerweise in der Initialisierungsmethode platziert
Tatsächlich kann die Lurcache -Klasse als Kartenklassenkarte verstanden werden. Es gibt Put and bekommen Methoden
Rufen Sie als Nächst
Lurcache's Add:
public void putbitmaptocache (String -URL, Bitmap Bitmap) {if (get (getBitMapfromcache (url) == null) {// Beurteilen Sie, ob der aktuelle Cache lrucache.put (URL, Bitmap); }} Lurcache get: public bitmap getbitmap fromCache (String url) {return lRucache.get (URL); // lrucache kann als Karte angesehen werden} Das Aufrufen der oben genannten Hinzufügen und Erhalten von Methoden kann Ressourcen zwischenspeichern, was recht einfach ist.
Seien Sie jedoch vorsichtig, dass LruCache lruCache=new LruCache<String, Bitmap>(cachSize) nur einmal neu sein kann, andernfalls werden verschiedene Objekte unterschiedlich zwischengespeichert.
Mit Androids Lrucache -Klasse beigefügt
Paket Android.util; import Java.util.linkedhashMap; import Java.util.map; /*** Ein Cache, der starke Hinweise auf eine begrenzte Anzahl von Werten hat. Jedes Mal * wird auf ein Wert auf den Kopf einer Warteschlange bewegt. Wenn ein Wert * zu einem vollständigen Cache hinzugefügt wird, wird der Wert am Ende dieser Warteschlange vertrieben und kann * für die Müllsammlung berechtigt sein. * Cache spart eine starke Referenz, um die Anzahl der Inhalte zu begrenzen. Wenn auf den Artikel zugegriffen wird, wird der Artikel zum Kopf der Warteschlange wechselt. * Wenn ein neuer Artikel hinzugefügt wird, wenn der Cache voll ist, wird das Element am Ende der Warteschlange recycelt. * <P> Wenn Ihre zwischengespeicherten Werte Ressourcen enthalten, die explizit veröffentlicht werden müssen, * überschreiben {@link #EntryRemoved}. * Wenn ein Cache -Miss auf Bedarf für die entsprechenden Schlüssel berechnet werden sollte, * überschreiben {@link #create}. Dies vereinfacht den Anrufcode und ermöglicht ihm, dass ein Wert immer zurückgegeben wird, auch wenn ein Cache -Fehlschlag vorliegt. * Wenn das dem Schlüssel entsprechende Element verloren geht, schreiben Sie create () neu. Dies vereinfacht den Rufcode und wird immer zurückgegeben, auch wenn er verloren geht. * <p> standardmäßig wird die Cache -Größe in der Anzahl der Einträge gemessen. Überschreiben * {@link #Sizeof}, um den Cache in verschiedenen Einheiten zugrößen. Beispielsweise ist dieser Cache * auf 4 MIB Bitmaps begrenzt: Die Standard -Cache -Größe ist die Anzahl der gemessenen Elemente, und die Größe des Cache wird überschrieben, um die * Größe verschiedener Elemente zu berechnen. * <pre> {@Code * int cachesize = 4 * 1024 * 1024; // 4mib * lrucache <string, bitmap> bitmapcache = new lrucache <string, bitmap> (cachesize) { * protected int sizeof (String -Schlüssel, Bitmap -Wert) { * return value.getByTeCount (); *} *}} </pre> * * <p> Diese Klasse ist Thread-Safe. Führen Sie atomisch mehrere Cache -Operationen durch, indem Sie auf dem Cache synchronisieren: <pre> {@code * Synchronized (cache) { * if (cache.get (key) == null) { * cache.put (Schlüssel, Wert); *} *}} </pre> * * <p> Diese Klasse lässt Null nicht als Schlüssel oder Wert verwendet werden. Ein Rückgabe * Wert von Null von {@link #get}, {@link #put} oder {@link #remove} ist * eindeutig: Der Schlüssel war nicht im Cache. * Schlüssel oder Wert ist null * Wenn get (), put (), remove () return -Wert ist null, das entsprechende Element des Schlüssels befindet sich nicht im Cache */ öffentliche Klasse lrucache <k, v> {private endgültige linkedHasMap <k, v> map; /** Größe dieses Cache in Einheiten. Nicht unbedingt die Anzahl der Elemente. */ private int Größe; // die Größe, die private int maxsize gespeichert wurde; // der angegebene maximale Speicherplatz Private int putcount; // die Anzahl der privaten Int CreateCount; // die Anzahl der Male der Erstellung privater Int -Räumungscount; // die Anzahl der Male von recyceltem privatem int int hitcount; // Anzahl der Hits Private int Misscount; // Anzahl der verlorenen/** * @param maxSize für Caches, die {@link #Sizeof} nicht überschreiben, dies ist * die maximale Anzahl von Einträgen im Cache. Für alle anderen Caches * ist dies die maximale Summe der Größen der Einträge in diesem Cache. */ public lRucache (int maxSize) {if (maxSize <= 0) {werfen Sie neue illegalArgumentException ("maxSize <= 0"); } this.maxSize = maxSize; this.map = new LinkedHasMap <k, v> (0, 0,75f, true); } /** * Gibt den Wert für {@code key} zurück, wenn er im Cache vorliegt oder von {@code #create} erstellt werden kann. Wenn ein Wert zurückgegeben wurde, wird er in den Kopf der Warteschlange bewegt. Dies gibt NULL zurück, wenn ein Wert nicht zwischengespeichert wird und nicht erstellt werden kann. Geben Sie das entsprechende Element nach Schlüssel zurück oder erstellen Sie eine Rückgabe des entsprechenden Elements. Der entsprechende Element wechselt zum Kopf der Warteschlange, * Wenn der Wert des Elements nicht zwischengespeichert oder nicht erstellt werden kann, geben Sie NULL zurück. */ public Final v Get (k key) {if (key == null) {throw New nullPoInterException ("key == null"); } V mapValue; synchronisiert (this) {mapValue = map.get (Schlüssel); if (mapValue! = null) {hitCount ++; // return mapValue klicken; } MissCount ++; // verloren} / * * Versuch, einen Wert zu schaffen. Dies kann lange dauern, und die Karte * kann anders sein, wenn create () zurückgibt. Wenn ein widersprüchlicher Wert * zur MAP hinzugefügt wurde, während er Create () funktioniert, lassen wir diesen Wert in * der Karte und geben den erstellten Wert frei. * Wenn es fehlt, versuchen Sie, ein Element zu erstellen */ v createdValue = create (Schlüssel); if (createdValue == null) {return null; } synchronisiert (this) {createCount ++; // create ++ mapValue = map.put (Schlüssel, erstelltValue); if (mapValue! } else {size += safesizeof (Schlüssel, erstelltValue); }} if (mapValue! = null) {Entremoved (false, key, createdValue, mapValue); MapValue zurückgeben; } else {trimToSize (maxSize); return createdValue; }} /*** caches {@code value} für {@code key}. Der Wert wird auf den Kopf der Warteschlange verschoben. * * @return den vorherigen Wert, der von {@code key} abgebildet ist. */ public final v put (k key, v value) {if (key == null || value == null) {neue nullPointerexception ("key == null || value == null"); } V vorher; synchronisiert (this) {putCount ++; Größe += Safesizeof (Schlüssel, Wert); vorher = map.put (Schlüssel, Wert); if (vorher! }} if (vorher! } trimToSize (maxSize); Zurück zurückkehren; } /*** @param maxSize die maximale Größe des Cache vor der Rückkehr. Kann -1 * sein, um selbst 0 -Größe Elemente zu räumen. * Cache -Space löschen*/ private void trimTosize (int maxSize) {while (true) {k key; V Wert; synchronisiert (this) {if (size <0 || (map.empty () && size! } if (Größe <= maxSize) {break; } Map.entry <k, v> toevict = map.eldest (); if (toevict == null) {break; } key = toevict.getKey (); value = toevict.getValue (); map.remove (Schlüssel); Größe -= Safesizeof (Schlüssel, Wert); evictionCount ++; } EntremedRemoved (true, key, value, null); }} /*** entfernt den Eintrag für {@code key}, wenn er existiert. * Löschen Sie das entsprechende Cache -Element des Schlüssels und geben Sie den entsprechenden Wert zurück * @return den vorherigen Wert, der von {@Code Key} abgebildet ist. */ public final v remove (k key) {if (key == null) {thrower New NullPoIterexception ("Key == NULL"); } V vorher; synchronisiert (this) {vorher = map.remove (Schlüssel); if (vorher! }} if (vorher! } Zurück zurück; } /*** forderte Einträge, die vertrieben oder entfernt wurden. Diese Methode wird aufgerufen, wenn ein Wert so vertrieben wird, dass es Platz macht, durch einen Anruf bei * {@link #remove} entfernt oder durch einen Anruf bei {@link #put} ersetzt wird. Die Standard -Implementierung von * tut nichts. * Aufgerufen, wenn der Artikel recycelt oder gelöscht wird. Ändern Sie die Methode, wenn der Wert recycelt wird, und befreit den Speicherplatz, er wird aufgerufen, oder wenn der Artikelwert ersetzt wird, tut die Standardimplementierung nichts. * <p> Die Methode wird ohne Synchronisation aufgerufen: Andere Threads können auf den Cache zugreifen, während diese Methode ausführt. * * @param evicted true, wenn der Eintrag entfernt wird, um Platz zu schaffen. * true --- put oder entfernen Ursachen * @param newValue den neuen Wert für {@code key}, wenn es existiert. Wenn nicht null, * wurde diese Entfernung durch einen {@link #put} verursacht. Ansonsten wurde es durch * eine Räumung oder eine {@link #remove} verursacht. * / Protected void EntremedRemoved (Boolean Evicted, K Key, V OldValue, v NewValue) {} / *** Rufen nach einem Cache -Miss zum Berechnen eines Wertes für den entsprechenden Schlüssel an. * Gibt den berechneten Wert oder Null zurück, wenn kein Wert berechnet werden kann. Die * Standardimplementierung gibt NULL zurück. * Wenn ein Element verloren geht, wird er aufgerufen und gibt den berechneten entsprechenden Wert oder NULL zurück * <p> Die Methode wird ohne Synchronisation aufgerufen: Andere Threads können auf den Cache zugreifen, während diese Methode ausgeführt wird. * * <p> Wenn ein Wert für {@code key} im Cache vorliegt, wenn diese Methode * zurückgibt, wird der erstellte Wert mit {@link #EntryRemoved} * veröffentlicht und offengelegt. Dies kann auftreten, wenn mehrere Threads gleichzeitig denselben Schlüssel * anfordern (was zu einer Erstellung mehrerer Werte führt) oder wenn ein * Thread {@link #put} aufruft, während ein anderer einen Wert für denselben * Taste erstellt. */ protected v create (k key) {return null; } private int safesizeof (k key, v -Wert) {int result = sizeof (Schlüssel, Wert); if (result <0) {werfen Sie eine neue illegaleStateException aus ("Negative Größe:" + key + "=" + value); } Rückgabeergebnis; } /** * Gibt die Größe des Eintrags für {@code key} und {@code value} in * benutzerdefinierte Einheiten zurück. Die Standardimplementierung gibt 1 zurück, so dass die Größe * die Anzahl der Einträge ist und die maximale Größe die maximale Anzahl von Einträgen ist. * Rückgabe Die Größe des benutzerdefinierten Elements, Standardrückgabe 1 repräsentiert die Anzahl der Elemente. Die maximale Größe ist der maximale Elementwert* <p> Die Größe eines Eintrags darf sich nicht ändern, während sie sich im Cache befindet. */ Protected int sizeof (k key, v Wert) {return 1; } /*** Löschen Sie den Cache und rufen Sie bei jedem entfernten Eintrag {@link #Entryremoved} auf. * Cache Cache */ public Final void evictall () {trimTosize (-1); // -1 werden 0 -Größe Elemente räumen} /** * für Caches, die {@link #Sizeof} nicht überschreiben, wodurch die Nummer * der Einträge im Cache zurückgegeben wird. Für alle anderen Caches gibt dies die Summe der Größen der Einträge in diesem Cache zurück. */ public synchronisierte endgültige int size () {return size; } /** * Für Caches, die {@link #Sizeof} nicht überschreiben, gibt dies die maximale * Anzahl der Einträge im Cache zurück. Für alle anderen Caches gibt dies die maximale Summe der Größen der Einträge in diesem Cache zurück. */ public synchronisierte endgültige int maxSize () {return maxSize; } /** * Gibt die Anzahl der Zeiten zurück, die {@link #get} zurückgegeben hat, einen Wert, der * bereits im Cache vorhanden war. */ public synchronisierte endgültige int hitcount () {return hitcount; } /** * Gibt die Anzahl der Zeiten zurück {@link #get} zurückgegeben oder benötigt einen neuen * Wert, der erstellt werden muss. */ public synchronisierte endgültige int Misscount () {return MissCount; } /*** Gibt die Anzahl {@link #create (Objekt)} zurück, die einen Wert zurückgegeben hat. */ public synchronisierte endgültige int createCount () {return createCount; } /*** Gibt die Anzahl der Zeiten zurück. {@Link #put} wurde aufgerufen. */ public synchronisierte endgültige int putcount () {return putCount; } /*** Gibt die Anzahl der vertriebenen Werte zurück. */ public synchronisierte endgültige int evictionCount () {return evictionCount; } /** * Gibt eine Kopie des aktuellen Inhalts des Cache zurück, der von kürzlich auf Zugriff auf zugegriffen bestellt wurde. Gibt eine Kopie des aktuellen Cache zurück, von dem von vor kurzem aufgerufenen Zugriff auf zuerst zugegriffen wird. public synchronisierte endgültige Karte <k, v> snapshot () {neu LinkedHasMap <K, v> (MAP) zurückgeben; } @Override public synchronisierte endgültige String toString () {int accesses = hitCount + MissCount; int hitpercent = Zugriffe! = 0? (100 * HitCount / Zugriff): 0; return String.Format ("lrucache [maxSize =%d, hits =%d, fehlsts =%d, hitrate =%d %%]", maxSize, hitcount, MissCount, Hitpercent); }}