編輯：關於android開發
Android開發難免會遇到加載網絡圖片問題，而加載網絡圖片難免會遇到多次重復請求加載同一張圖片問題，這麼一來就導致多次加載網絡，不僅浪費資源而且給用戶體驗感覺加載圖片慢。從Android3.1開始，API中多了一個LruCache類，該類是一個使用最近最少使用算法的緩存類。也就是可以把上次下載的圖片以鍵值對的方式保存在緩存中，以便下載加載同一張圖片時無須再次從網絡上下載，而且加載速度快。
這裡我把LruCache源碼貼出來，幾乎每行代碼的注釋都有，很詳細，有意者可以仔細跟著注釋閱讀源碼，以便理解LruCache類的原理。
/**
1.從類名LruCache就知道，該類的作用是一個最近最少使用算法來維護的一個緩存類。
2.該類是一個用於緩存一定數量的值，並且該緩存對象是持有強引用。
3.每當成功get一次值時，該值都會移動到鏈表的頭部，以便標記該值為最近最新的值。
4.當緩存滿了時，鏈表尾部的值會被認為是最近最少使用的值，會被從鏈表中移除，以便緩存有空間保存新的值。
5.緩存中鏈表的值發生改變時會調用空方法entryRemoved，開發者可以重寫該方法，以便做相應的操作。
6.開發者應該去重寫該類中sizeOf方法，該方法返回每個key對應value值得大小，以便該類去維護緩存的大小。
7.該類是一個安全類。同時該類不允許key和value為空。該類在Android3.1之後添加到源碼中。
**/
package android.util;
import java.util.LinkedHashMap;
import java.util.Map;
public class LruCache {
private final LinkedHashMap map;
/** Size of this cache in units. Not necessarily the number of elements. */
private int size;//已使用緩存大小
private int maxSize;//總的緩存大小
private int putCount;//添加記錄次數
private int createCount;//創建次數
private int evictionCount;//移除次數
private int hitCount;//命中次數
private int missCount;//未命中次數
/**
* @param maxSize for caches that do not override {@link #sizeOf}, this is
* the maximum number of entries in the cache. For all other caches,
* this is the maximum sum of the sizes of the entries in this cache.
*/
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
this.map = new LinkedHashMap(0, 0.75f, true);//創建鏈表緩存，該鏈表緩存是整個LruCache類的重點。
}
/**
* Sets the size of the cache.
* @param maxSize The new maximum size.
*重新設置緩存大小
* @hide
*/
public void resize(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
synchronized (this) {
this.maxSize = maxSize;
}
trimToSize(maxSize);
}
/**
* Returns the value for {@code key} if it exists in the cache or can be
* created by {@code #create}. If a value was returned, it is moved to the
* head of the queue. This returns null if a value is not cached and cannot
* be created.
* 根據key值獲得緩存中對應的數據，該方法是線程安全的。
*/
public final V get(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V mapValue;
synchronized (this) {//加鎖線程安全
mapValue = map.get(key);//從鏈表中去取緩存數據
if (mapValue != null) {//獲取數據成功
hitCount++;//標記命中的次數
return mapValue;//返回命中的數據,命中之後直接返回
}
missCount++;//標記未命中的次數
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
*/
//未命中走以下流程
V createdValue = create(key);//創建新的數據，默認返回null，創建的時候可以重寫該方法，以便未命中的時候創建一個新的數據添加到緩存鏈表中。
if (createdValue == null) {
return null;//未命中時默認到這裡結束。
}
//以下代碼是在未命中時創建新數據添加到鏈表緩存中。
synchronized (this) {
createCount++;//標記創建新數據的次數
mapValue = map.put(key, createdValue);
//如果鏈表中已有該key對應的值，則最後取消添加新創建的值。很多人可能感到奇怪，此時鏈表中應該不存在key對應的值啊？其實這裡是為了防止多線程操作導致數據不同步而添加的安全代碼。不懂得自己體會去吧！
if (mapValue != null) {
// There was a conflict so undo that last put
map.put(key, mapValue);
} else {
//標記已經使用了的內存大小。
size += safeSizeOf(key, createdValue);
}
}
if (mapValue != null) {
//鏈表中發生數據變化時（調用了put，get方法）調用該方法。該方法默認是個空，開發者可以重寫該方法在鏈表中數據變化時做相應的操作。
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
//重新整理當前鏈表維護的內存。
trimToSize(maxSize);
return createdValue;
}
}
/**
* Caches {@code value} for {@code key}. The value is moved to the head of
* the queue.
*
* @return the previous value mapped by {@code key}.
* 添加新的鍵值對到鏈表中
*/
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
//同步操作
synchronized (this) {
putCount++;//標記添加數據的次數
size += safeSizeOf(key, value);//標記已使用的內存大小
previous = map.put(key, value);//保存數據到鏈表
if (previous != null) {//鏈表中已存在key對應的值則替換原來的值
size -= safeSizeOf(key, previous);//標記已使用的內存大小
}
}
if (previous != null) {
//鏈表中數據發生交換時調用該方法。
entryRemoved(false, key, previous, value);
}
//整理鏈表維護的內存大小
trimToSize(maxSize);
return previous;
}
/**
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
* 管理鏈表中內存的大小
*/
private void trimToSize(int maxSize) {
while (true) {
K key;
V value;
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
//當已經使用了的內存小於申請的最大內存，則說明鏈表未滿，還可以添加新的數據。
if (size <= maxSize) {
break;
}
// BEGIN LAYOUTLIB CHANGE
// get the last item in the linked list.
// This is not efficient, the goal here is to minimize the changes
// compared to the platform version.
Map.Entry toEvict = null;
//for循環得到鏈表末尾的數據，然後移除它。
for (Map.Entry entry : map.entrySet()) {
toEvict = entry;
}
// END LAYOUTLIB CHANGE
if (toEvict == null) {
break;
}
//移除鏈表末尾的一個數據，該數據就是最近最少使用到的數據。
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);//移除數據
size -= safeSizeOf(key, value);//重寫計算已使用的內存大小
evictionCount++;//標記移除數據的次數
}
//開發者可以重新改方法，當移除數據時做相應的操作。
entryRemoved(true, key, value, null);
}
}
/**
* Removes the entry for {@code key} if it exists.
*
* @return the previous value mapped by {@code key}.
* 從鏈表中移除數據的方法
*/
public final V remove(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V previous;
synchronized (this) {
previous = map.remove(key);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, null);
}
return previous;
}
/**
* Called for entries that have been evicted or removed. This method is
* invoked when a value is evicted to make space, removed by a call to
* {@link #remove}, or replaced by a call to {@link #put}. The default
* implementation does nothing.
*
*The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
* @param evicted true if the entry is being removed to make space, false
* if the removal was caused by a {@link #put} or {@link #remove}.
* @param newValue the new value for {@code key}, if it exists. If non-null,
* this removal was caused by a {@link #put}. Otherwise it was caused by
* an eviction or a {@link #remove}.
*/
//該方法默認是一個空方法。當鏈表中發生數據變化時調用該方法，所以開發者可以重寫該方法，以便做相應的操作。
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}
/**
* Called after a cache miss to compute a value for the corresponding key.
* Returns the computed value or null if no value can be computed. The
* default implementation returns null.
*
*
The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
*
If a value for {@code key} exists in the cache when this method
* returns, the created value will be released with {@link #entryRemoved}
* and discarded. This can occur when multiple threads request the same key
* at the same time (causing multiple values to be created), or when one
* thread calls {@link #put} while another is creating a value for the same
* key.
*/
//該方法默認返回空，開發者可以重新該方法以便在get鏈表中的數據失敗時創建新的數據添加到鏈表中。
protected V create(K key) {
return null;
}
//該方法是重寫計算鏈表中已經使用了的內存大小
private int safeSizeOf(K key, V value) {
int result = sizeOf(key, value);
if (result < 0) {
throw new IllegalStateException("Negative size: " + key + "=" + value);
}
return result;
}
/**
* Returns the size of the entry for {@code key} and {@code value} in
* user-defined units. The default implementation returns 1 so that size
* is the number of entries and max size is the maximum number of entries.
*
*
An entry's size must not change while it is in the cache. */ //該方法默認返回1，開發者必須重寫該方法，用來計算每個key對應value值得大小，以便維護鏈表中緩存的大小。 protected int sizeOf(K key, V value) { return 1; } /** * Clear the cache, calling {@link #entryRemoved} on each removed entry. */ //移除鏈表中所有的數據 public final void evictAll() { trimToSize(-1); // -1 will evict 0-sized elements } /** * For caches that do not override {@link #sizeOf}, this returns the number * of entries in the cache. For all other caches, this returns the sum of * the sizes of the entries in this cache. * 得到已經使用緩存中內存的大小 */ public synchronized final int size() { return size; } /** * For caches that do not override {@link #sizeOf}, this returns the maximum * number of entries in the cache. For all other caches, this returns the * maximum sum of the sizes of the entries in this cache. * 得到分配給鏈表緩存的大小 */ public synchronized final int maxSize() { return maxSize; } /** * Returns the number of times {@link #get} returned a value that was * already present in the cache. * 得到命中的次數 */ public synchronized final int hitCount() { return hitCount; } /** * Returns the number of times {@link #get} returned null or required a new * value to be created. * 得到未命中的次數 */ public synchronized final int missCount() { return missCount; } /** * Returns the number of times {@link #create(Object)} returned a value. * 得到創建新數據的次數 */ public synchronized final int createCount() { return createCount; } /** * Returns the number of times {@link #put} was called. * 得到添加新數據次數 */ public synchronized final int putCount() { return putCount; } /** * Returns the number of values that have been evicted. * 得到移除數據的次數 */ public synchronized final int evictionCount() { return evictionCount; } /** * Returns a copy of the current contents of the cache, ordered from least * recently accessed to most recently accessed. * 得到鏈表對象 */ public synchronized final Map
一下代碼是圖片緩存類ImageCache示例代碼：
import android.graphics.Bitmap;
import android.util.LruCache;
/**
* Created by xjp on 2016/4/2.
*/
public class ImageCache {
private LruCache mLruCache;
private static ImageCache instance = new ImageCache();
public ImageCache() {
//得到當前應用總的內存大小
int appTotalCache = (int) Runtime.getRuntime().totalMemory();
//取當前應用內存的1/8作為緩存大小
int maxSize = appTotalCache / 8;
mLruCache = new LruCache(maxSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
//此處返回每個Bitmap對象的大小。值得注意：此處返回值並不是圖片的張數，
// 且返回值的單位應該和maxSize的單位一樣。也就是maxSize單位是B，那麼此處返回值單位也是B
return value.getByteCount();
}
@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
//如果緩存中的值被移除，則去回收Bitmap內存。
if (evicted) {
if (oldValue != null && !oldValue.isRecycled()) {
oldValue.recycle();
}
}
}
};
}
public static ImageCache getInstance() {
return instance;
}
//從緩存中讀取數據
public Bitmap getBitmapFromCache(String key) {
if (mLruCache != null) {
mLruCache.get(key);
}
return null;
}
//保存數據到緩存中
public void putBitmapToCache(String key, Bitmap value) {
if (mLruCache != null) {
if (mLruCache.get(key) == null) {
mLruCache.put(key, value);
}
}
}
//清除緩存中所有數據
public void clearCache() {
if (mLruCache != null) {
mLruCache.evictAll();
}
}
}
總結：以後就可以直接用ImageCache類來作為圖片緩存了。
Android數據庫相關整理，android數據庫整理
Android數據庫相關整理，android數據庫整理今天對Android中數據庫相關的操作和代碼做了一個整理，便於自己之後的查閱。主要內容有： 1.原生數據庫寫法 2.
Android Studio基本使用，androidstudio
Android Studio基本使用，androidstudio本文為原創文章，轉載請注明出處。 本文主要推薦給由Eclipse開發轉向使用Android Studio（
Fragment配合RadioGroup實現點擊切換布局，fragmentradiogroup
Fragment配合RadioGroup實現點擊切換布局，fragmentradiogroup 這裡用了 compile com.jakewharton:butter
畫畫板--第三方開源--DrawableView，畫板--drawableview
畫畫板--第三方開源--DrawableView，畫板--drawableview Android上的第三方開源DrawableView支持手
