Misalnya, Cache Network memuat gambar:
// Dapatkan memori maksimum yang dialokasikan oleh aplikasi int maxmemory = (int) runtime.getRuntime (). MaxMemory (); // Dapatkan 1/5 dari memori untuk digunakan ketika ukuran cache adalah int cacheSize = maxMemory/5; // lrucache instan lrucache = baru lrucache <string, bitmap> (cachsize) {// metode internal sizeof mengatur ukuran cache dari setiap gambar yang dilindungi ukuran (tombol string, nilai bitmap) {// dipanggil setiap kali cache disimpan untuk memberi tahu sistem seberapa besar citra cache ini // semua ukuran cache disimpan untuk mengatakan seberapa besar gambar cache/ value.getByTecount (); }}; Kode di atas biasanya ditempatkan dalam metode inisialisasi
Bahkan, kelas Lurcache dapat dipahami sebagai peta kelas peta. Ada metode put dan dapatkan
Selanjutnya, hubungi put dan dapatkan metode untuk mengakses sumber daya yang di -cache
Tambahkan Lurcache:
public void putbitMaptocache (string url, bitmap bitmap) {if (getBitMapfromCache (url) == null) {// menilai apakah cache saat ini ada lrucache.put (url, bitmap); }} Lurcache get: bitmap publik getBitmap fromcache (string url) {return lrucache.get (url); // lrucache dapat dianggap sebagai peta} Menyebut metode Tambah dan Dapatkan di atas dapat cache sumber daya, yang cukup sederhana.
Tetapi hati -hati bahwa LruCache lruCache=new LruCache<String, Bitmap>(cachSize) hanya bisa menjadi baru sekali, jika tidak objek yang berbeda akan di -cache secara berbeda.
Dilampirkan dengan kelas LRUCACHE Android
paket android.util; impor java.util.linkedhashmap; impor java.util.map; /*** cache yang memiliki referensi kuat untuk sejumlah nilai. Setiap kali * nilai diakses, dipindahkan ke kepala antrian. Ketika suatu nilai * ditambahkan ke cache penuh, nilai pada akhir antrian itu diusir dan mungkin * menjadi memenuhi syarat untuk pengumpulan sampah. * Cache menyimpan referensi yang kuat untuk membatasi jumlah konten. Setiap kali item diakses, item akan bergerak ke kepala antrian. * Ketika item baru ditambahkan ketika cache penuh, item di akhir antrian akan didaur ulang. * <p> Jika nilai -nilai cache Anda memiliki sumber daya yang perlu dirilis secara eksplisit, * override {@link #entryremoved}. * Jika cache miss harus dihitung berdasarkan permintaan untuk tombol yang sesuai, * override {@link #Create}. Ini menyederhanakan kode panggilan, memungkinkannya untuk * mengasumsikan nilai akan selalu dikembalikan, bahkan ketika ada cache miss. * Jika item yang sesuai dengan kunci hilang, tulis ulang create (). Ini menyederhanakan kode panggilan dan akan selalu kembali meskipun hilang. * <p> Secara default, ukuran cache diukur dalam jumlah entri. Override * {@link #sizeof} untuk mengukur cache dalam unit yang berbeda. Misalnya, cache ini * dibatasi hingga 4mib bitmap: ukuran cache default adalah jumlah item yang diukur, dan ukuran cache ditimpa untuk menghitung * ukuran item yang berbeda. * <pr Pre> {@code * int cacheSize = 4 * 1024 * 1024; // 4mib * lrucache <string, bitmap> bitmapcache = new lrucache <string, bitmap> (cacheSize) { * protected int sizeof (tombol string, nilai bitmap) { * return value.getByTecount (); *} *}} </pr Pre> * * <p> Kelas ini aman. Lakukan beberapa operasi cache secara atomis dengan * menyinkronkan pada cache: <pe> {@code * disinkronkan (cache) { * if (cache.get (key) == null) { * cache.put (key, value); *} *}} </pr Pre> * * <p> Kelas ini tidak mengizinkan NULL digunakan sebagai kunci atau nilai. Nilai return * null dari {@link #get}, {@link #put} atau {@link #remove} adalah * tidak ambigu: kunci tidak ada di cache. * Kunci atau nilainya adalah null * when get (), put (), hapus () nilai pengembalian adalah nol, item yang sesuai dari kunci tidak ada dalam cache */ kelas publik lrucache <k, v> {private final linkedHashMap <k, v> peta; /** Ukuran cache ini dalam unit. Belum tentu jumlah elemen. */ ukuran int pribadi; // ukuran yang telah disimpan int private int maxSize; // ruang penyimpanan maksimum yang ditentukan int private intcount; // Jumlah createCount int private; // berapa kali pembuatan private int eVictionCount; // berapa kali rekycled private int int hitcount; // Jumlah hit pribadi int missount; // Jumlah Lost/** * @param MaxSize untuk cache yang tidak mengganti {@link #sizeof}, ini adalah * jumlah maksimum entri dalam cache. Untuk semua cache lainnya, * Ini adalah jumlah maksimum dari ukuran entri dalam cache ini. */ lrucache publik (int maxSize) {if (maxSize <= 0) {lempar new ilegalArgumentException ("maxSize <= 0"); } this.maxSize = MaxSize; this.map = new LinkedHashMap <k, v> (0, 0.75f, true); } /** * Mengembalikan nilai untuk {@code key} jika ada dalam cache atau dapat * dibuat oleh {@code #Create}. Jika nilai dikembalikan, dipindahkan ke * kepala antrian. Ini mengembalikan nol jika nilai tidak di -cache dan tidak dapat * dibuat. Kembalikan item yang sesuai dengan kunci, atau buat pengembalian item yang sesuai. Item yang sesuai akan pindah ke kepala antrian, * jika nilai item tidak di -cache atau tidak dapat dibuat, return null. */ final public v get (k key) {if (key == null) {throw new nullpointerException ("key == null"); } V MapValue; disinkronkan (this) {mapValue = map.get (key); if (mapValue! = null) {Hitcount ++; // tekan return mapValue; } misscount ++; // Lost} / * * Berusaha membuat nilai. Ini mungkin memakan waktu lama, dan peta * mungkin berbeda saat membuat () kembali. Jika nilai yang bertentangan * ditambahkan ke peta saat create () berfungsi, kami meninggalkan nilai itu di * peta dan melepaskan nilai yang dibuat. * Jika hilang, cobalah membuat item */ v createdValue = create (key); if (createdValue == null) {return null; } disinkronkan (this) {createCount ++; // create ++ mapValue = map.put (tombol, createdValue); if (mapValue! = null) {// Ada konflik jadi lepaskan put terakhir // jika ada oldValue sebelum itu, hapus put () map.put (key, mapValue); } else {size += safesizeof (kunci, createdValue); }} if (mapValue! = null) {entryremoved (false, key, createdValue, mapValue); mengembalikan mapValue; } else {trimtosize (maxSize); Return CreateValue; }} /*** cache {@code value} untuk {@code key}. Nilainya dipindahkan ke kepala * antrian. * * @return Nilai sebelumnya dipetakan oleh {@code key}. */ public final v put (key k, value v) {if (key == null || value == null) {lempar nullPointerException baru ("key == null || value == null"); } V Sebelumnya; disinkronkan (ini) {putcount ++; ukuran += safesizeof (kunci, nilai); Sebelumnya = Map.put (tombol, nilai); if (sebelumnya! = null) {// Nilai sebelumnya yang dikembalikan adalah ukuran -= SafesizeOf (key, sebelumnya); }} if (sebelumnya! = null) {entryremoved (false, key, sebelumnya, value); } trimtosize (MaxSize); kembalikan sebelumnya; } /*** @param Maxsize Ukuran maksimum cache sebelum kembali. Mungkin -1 * untuk mengusir elemen berukuran 0. * CLEAR Cache Space*/ Private void trimtosize (int maxSize) {while (true) {k key; Nilai v; disinkronkan (this) {if (size <0 || (map.isempty () && size! = 0)) {lempar baru ilegalstateException (getSclass (). getName () + ".sizeof () melaporkan hasil yang tidak konsisten!"); } if (size <= maxSize) {break; } Map.entry <k, v> toevict = map.eldest (); if (toevict == null) {break; } key = toevict.getKey (); nilai = toevict.getValue (); peta.remove (kunci); size -= SafesizeOf (kunci, nilai); EvictionCount ++; } entryremoved (true, key, value, null); }} /*** Menghapus entri untuk {@code Key} jika ada. * Hapus item cache yang sesuai dari kunci dan kembalikan nilai yang sesuai * @Return nilai sebelumnya dipetakan oleh {@code Key}. */ final public v Remove (K key) {if (key == null) {throw new nullpointerException ("key == null"); } V Sebelumnya; disinkronkan (ini) {sebelumnya = map.remove (key); if (sebelumnya! = null) {size -= safesizeof (key, sebelumnya); }} if (sebelumnya! = null) {entryremoved (false, key, sebelumnya, null); } kembalikan sebelumnya; } /*** Memanggil entri yang telah diusir atau dihapus. Metode ini * dipanggil ketika suatu nilai diusir untuk membuat ruang, dihapus dengan panggilan ke * {@link #remove}, atau diganti dengan panggilan ke {@link #put}. Implementasi default * tidak melakukan apa -apa. * Dipanggil saat item didaur ulang atau dihapus. Ubah metode ketika nilainya didaur ulang dan membebaskan ruang penyimpanan, itu disebut hapus, atau ketika nilai item diganti, implementasi default tidak melakukan apa -apa. * <p> Metode ini dipanggil tanpa sinkronisasi: utas lain dapat * mengakses cache saat metode ini dijalankan. * * @param diusir true jika entri sedang dihapus untuk membuat ruang, false * Jika penghapusan disebabkan oleh {@link #put} atau {@link #remove}. * Benar --- Letakkan atau hapus penyebab * @param newValue nilai baru untuk {@code key}, jika ada. Jika non-null, * penghapusan ini disebabkan oleh {@link #put}. Kalau tidak, itu disebabkan oleh * penggusuran atau {@link #remove}. * / void entryremoved (boolean diusir, K key, v oldValue, v newValue) {} / *** dipanggil setelah cache miss untuk menghitung nilai untuk kunci yang sesuai. * Mengembalikan nilai yang dihitung atau nol jika tidak ada nilai yang dapat dihitung. Implementasi default * mengembalikan nol. * Ketika suatu item hilang, itu akan dipanggil, mengembalikan nilai yang sesuai yang dihitung atau nol * <p> Metode ini dipanggil tanpa sinkronisasi: utas lain dapat * mengakses cache saat metode ini dieksekusi. * * <p> Jika nilai untuk {@code Key} ada di cache saat metode ini * kembali, nilai yang dibuat akan dirilis dengan {@link #entryremoved} * dan diungkapkan. Ini dapat terjadi ketika beberapa utas meminta kunci yang sama * pada saat yang sama (menyebabkan beberapa nilai dibuat), atau ketika satu * utas memanggil {@link #put} sementara yang lain membuat nilai untuk kunci * yang sama. */ Protected v Create (K key) {return null; } private int safesizeof (Key k, nilai v) {int result = sizeof (key, value); if (hasil <0) {lempar IllegalStateException baru ("ukuran negatif:" + key + "=" + nilai); } hasil pengembalian; } /** * Mengembalikan ukuran entri untuk {@code key} dan {@code value} di * unit yang ditentukan pengguna. Implementasi default mengembalikan 1 sehingga ukuran * adalah jumlah entri dan ukuran maksimum adalah jumlah maksimum entri. * Mengembalikan ukuran item yang ditentukan pengguna, Default Return 1 mewakili jumlah item, ukuran maksimum adalah nilai item maksimum* <p> Ukuran entri tidak boleh berubah saat berada di cache. */ SIZEOF INT DROCTED (KEY K, Nilai V) {return 1; } /*** Hapus cache, panggil {@link #entryremoved} pada setiap entri yang dihapus. * CLEAR CACHE */ PUBLIK FINAL VOID EVICTALL () {TRIMTOSIZE (-1); // -1 akan mengusir elemen berukuran 0} /** * untuk cache yang tidak mengganti {@link #sizeof}, ini mengembalikan nomor * entri dalam cache. Untuk semua cache lainnya, ini mengembalikan jumlah * ukuran entri dalam cache ini. */ Ukuran int final yang disinkronkan publik () {ukuran pengembalian; } /** * Untuk cache yang tidak mengganti {@link #sizeof}, ini mengembalikan jumlah entri maksimum * dalam cache. Untuk semua cache lainnya, ini mengembalikan * jumlah maksimum dari ukuran entri dalam cache ini. */ public final int int maxSize () {return maxSize; } /** * Mengembalikan berapa kali {@link #get} mengembalikan nilai yang * sudah ada di cache. */ public final int hitcount () {return hitcount; } /** * Mengembalikan berapa kali {@link #get} dikembalikan nol atau membutuhkan nilai * baru untuk dibuat. */ Public Synchronized final int misscount () {return misscount; } /*** Mengembalikan jumlah kali {@link #create (objek)} Mengembalikan nilai. */ public final int createCount () {return createCount; } /*** Mengembalikan berapa kali {@link #put} dipanggil. */ Public Synchronized final intcount () {return putcount; } /*** Mengembalikan jumlah nilai yang telah diusir. */ Public Sinkronisasi Int EvictionCount () {return EvictionCount; } /** * Mengembalikan salinan konten cache saat ini, dipesan dari paling tidak * baru -baru ini diakses ke yang paling baru diakses. Mengembalikan salinan cache saat ini, dari yang paling baru diakses ke yang paling baru diakses. peta akhir yang disinkronkan publik <k, v> snapshot () {return new LinkedHashMap <k, v> (peta); } @Override Public Sinkronisasi String akhir ToString () {int Accessses = HitCount + MissCount; int hitpercent = akses! = 0? (100 * HitCount / Accessses): 0; return string.Format ("LRUCACHE [MAXSIZE =%D, HITS =%D, Misses =%D, Hitrate =%D %%]", MaxSize, Hitcount, MissCount, Hitpercent); }}