前两篇我们介绍了一般的优化ListView方法以及DiskLruCache优化ListView，见android-----带你一步一步优化ListView(一)和android-----带你一步一步优化ListView(二)，这一篇我们将从内存缓存的角度来完成ListView的优化，使用的是LruCache，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除，并没有一个固定的缓存大小是符合所有应用程序的，我们应该根据自己应用程序的状况设置出合理的缓存大小，下面我们通过实例来学习一下LruCache具体怎么使用：
首先定义显示ListView的布局文件：listview.xml
1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. "match_parent"
4. "match_parent"
5. "vertical" >
6. <ListView
7. "@+id/listView"
8. "match_parent"
9. "match_parent">
10. </ListView>
11. </LinearLayout> 接着定义每个item显示的样式item.xml
1. <?xml version="1.0" encoding="utf-8"?>
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. "match_parent"
4. "match_parent"
5. "vertical" >
6. <ImageView
7. "@+id/imageView"
8. "50dp"
9. "50dp"
10. />
11. <TextView
12. "@+id/textView"
13. "100dp"
14. "50dp"
15. "@id/imageView"
16. "20dp"
17. "70dp"
18. />
19. </RelativeLayout> 接下来就是最重要的ListViewAdapter适配器内容了，代码有点长度，先贴出来，接下来慢慢解释：
1. public class ListViewAdapter extends BaseAdapter{
2.
3. //存储所有将要访问的路径
4. public List<String> list;
5. public LruCache<String, Bitmap> lruCache;
6. public LayoutInflater inflater;
7. public ListView listView;
8. public int reqWidth;
9. public int reqHeight;
10. public Set<ImageAsyncTask> tasks = new HashSet<ListViewAdapter.ImageAsyncTask>();
11.
12.
13. public ListViewAdapter(Context context,List<String> list,LruCache<String, Bitmap> lruCache,ListView listView,ImageView imageView)
14. {
15. this.list = list;
16. this.lruCache = lruCache;
17. this.inflater = LayoutInflater.from(context);
18. this.listView = listView;
19. LayoutParams params = imageView.getLayoutParams();
20. reqWidth = params.width;
21. reqHeight = params.height;
22. }
23. @Override
24. public int getCount() {
25. return list.size();
26. }
27.
28. @Override
29. public String getItem(int position) {
30. return list.get(position);
31. }
32.
33. @Override
34. public long getItemId(int position) {
35. return position;
36. }
37.
38. @Override
39. public View getView(int position, View convertView, ViewGroup parent) {
40. null;
41. null;
42. if(convertView == null)
43. {
44. null);
45. new ViewHolder();
46. holder.imageView = (ImageView) view.findViewById(R.id.imageView);
47. holder.textView = (TextView) view.findViewById(R.id.textView);
48. view.setTag(holder);
49. else
50. {
51. view = convertView;
52. holder = (ViewHolder) view.getTag();
53. }
54. //为ImageView以及TextView设置Tag防止出现乱序
55. holder.imageView.setTag(position);
56. "#");
57. return view;
58. }
59.
60. /**
61. * 添加当前key值对应的Bitmap到LruCache中
62. * @param key
63. * @param bitmap
64. */
65. public void addBitmapToMemoryCache(String key,Bitmap bitmap)
66. {
67. if(getBitmapFromMemoryCache(key) == null)
68. {
69. lruCache.put(key, bitmap);
70. }
71. }
72.
73. /**
74. * 从LruCache中获取对应于key的Bitmap对象
75. * @param key
76. * @return
77. */
78. public Bitmap getBitmapFromMemoryCache(String key)
79. {
80. return lruCache.get(key);
81. }
82.
83. /**
84. * 加载某一位置上的图片
85. * @param url
86. * @param position
87. */
88. public void loadImage(int position)
89. {
90. //获取到position位置对应的url
91. String url = getItem(position);
92. null;
93. bitmap = getBitmapFromMemoryCache(url);
94. if(bitmap != null)
95. {
96. //表示缓存中存在对应的于此url的Bitmap，则直接获得该Bitmap并且显示到ListView上面
97. ImageView imageView = (ImageView) listView.findViewWithTag(position);
98. "#");
99. if(imageView != null)
100. imageView.setImageBitmap(bitmap);
101. if(textView != null)
102. "从缓存中获取的");
103. else
104. {
105. //开启线程从网络中加载图片
106. new ImageAsyncTask(listView, position);
107. new OnImageLoadListener() {
108.
109. @Override
110. public void onSuccessLoad(Bitmap bitmap) {
111. "加载图片成功");
112. }
113.
114. @Override
115. public void onFailureLoad() {
116. "加载图片失败");
117. }
118. });
119. tasks.add(task);
120. //开启线程加载图片
121. }
122. }
123.
124. /**
125. * 暂停所有任务(为了防止在滑动的时候仍然有线程处于请求状态)
126. */
127. public void cancelTask()
128. {
129. if(tasks != null)
130. {
131. for(ImageAsyncTask task: tasks)
132. false);//暂停任务
133. }
134. }
135.
136. /**
137. * 对图片进行压缩处理
138. * @param in
139. * @param reqWidth
140. * @param reqHeight
141. * @return
142. */
143. public static Bitmap decodeSampleBitmapFromStream(InputStream in,int reqWidth,int reqHeight)
144. {
145. //设置BitmapFactory.Options的inJustDecodeBounds属性为true表示禁止为bitmap分配内存
146. new BitmapFactory.Options();
147. true;
148. byte[] data = inputStreamToByteArray(in);
149. //这次调用的目的是获取到原始图片的宽、高，但是这次操作是没有写内存操作的
150. 0, data.length, options);
151. options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
152. //设置这次加载图片需要加载到内存中
153. false;
154. 0, data.length, options);
155. return afterBitmap;
156. }
157.
158. /**
159. * 计算出压缩比
160. * @param options
161. * @param reqWith
162. * @param reqHeight
163. * @return
164. */
165. public static int calculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight)
166. {
167. //通过参数options来获取真实图片的宽、高
168. int width = options.outWidth;
169. int height = options.outHeight;
170. int inSampleSize = 1;//初始值是没有压缩的
171. if(width > reqWidth || height > reqHeight)
172. {
173. //计算出原始宽与现有宽，原始高与现有高的比率
174. int widthRatio = Math.round((float)width/(float)reqWidth);
175. int heightRatio = Math.round((float)height/(float)reqHeight);
176. //选出两个比率中的较小值，这样的话能够保证图片显示完全
177. inSampleSize = widthRatio < heightRatio ? widthRatio:heightRatio;
178. }
179. return inSampleSize;
180. }
181.
182. /**
183. * 将InputStream转换为Byte数组
184. * @param in
185. * @return
186. */
187. public static byte[] inputStreamToByteArray(InputStream in)
188. {
189. new ByteArrayOutputStream();
190. byte[] buffer = new byte[1024];
191. int len;
192. try {
193. while((len = in.read(buffer)) != -1)
194. {
195. 0, len);
196. }
197. catch (IOException e) {
198. e.printStackTrace();
199. finally{
200. try {
201. in.close();
202. outputStream.close();
203. catch (IOException e) {
204. e.printStackTrace();
205. }
206. }
207. return outputStream.toByteArray();
208. }
209. static class ViewHolder
210. {
211. ImageView imageView;
212. TextView textView;
213. }
214.
215. class ImageAsyncTask extends AsyncTask<String, Void, Bitmap>
216. {
217. public ListView listView;
218. public OnImageLoadListener listener;
219. public int position;
220.
221. public ImageAsyncTask(ListView listView,int position)
222. {
223. this.listView = listView;
224. this.position = position;
225. }
226.
227. public void setOnImageLoadListener(OnImageLoadListener listener)
228. {
229. this.listener = listener;
230. }
231. @Override
232. protected Bitmap doInBackground(String... params) {
233. 0];
234. null;
235. null;
236. null;
237. null;
238. try {
239. new URL(urlString);
240. connection = (HttpURLConnection) url.openConnection();
241. in = connection.getInputStream();
242. bitmap = decodeSampleBitmapFromStream(in, reqWidth, reqHeight);
243. //将当前Bitmap添加到缓存中
244. if(bitmap != null)
245. lruCache.put(urlString, bitmap);
246. catch (Exception e) {
247. e.printStackTrace();
248. }
249. return bitmap;
250. }
251.
252. @Override
253. protected void onPostExecute(Bitmap result) {
254. if(result != null)
255. {
256. listener.onSuccessLoad(result);
257. ImageView imageView = (ImageView) listView.findViewWithTag(position);
258. "#");
259. if(imageView != null)
260. imageView.setImageBitmap(result);
261. if(textView != null)
262. "从网络中获取的");
263. else
264. listener.onFailureLoad();
265. }
266. }
267. }其中39行的getView方法代码就是我们平常使用ListView的常规写法，复用convertView以及对每个view设置viewHolder，为防止图片加载出现乱序，第55、56行我们分别对ImageView以及TextView设置了Tag标志；
addBitmapToMemoryCache用于向LruCache中添加当前Bitmap位图，因为LruCache本身实际上是由LinkedHashMap实现的，所有调用的是put方法；
getBitmapFromMemoryCache方法用于从LruCache缓存中读取指定key值的Bitmap位图；
loadImage就是我们的核心代码，首先第91行会通过调用getItem方法来获得当前item条目所要加载图片的url，随后93行调用getBitmapFromMemoryCache查看缓存中是否存在指定key值的Bitmap，第94行进行判断，如果存在Bitmap的话，则进入if语句块中，97、98行通过findViewWithTag来获得对应条目的ImageView以及TextView，并且将当前获取到的缓存图片显示到当前item；如果当前缓存中不存在的话，则进入103行的else语句块中，106行定义一个ImageAsyncTask图片加载线程，并在119行将当前线程加入到Set<ImageAsyncTask>类型的tasks集合中，便于我们随后对加载图片线程进行控制，第120行调用execute方法，将当前需要加载图片的url传入；
doInBackground方法来加载图片，这里的图片加载方法和之前android-----带你一步一步优化ListView(二) 是一致的，不清楚的朋友可以看看上一篇博客，另外这里面也用到了图片压缩技术，不太懂的可以看看android-----解决Bitmap内存溢出的一种方法(图片压缩技术)，在图片压缩完成之后会在第245行将当前Bitmap添加到LruCache中，随后在onPostExecute中进行更新UI的操作即可啦；
最后就是MainActivity方法了：
1. public class MainActivity extends Activity implements OnScrollListener {
2.
3. public LruCache<String, Bitmap> memoryCache;
4. public int start_index;
5. public int end_index;
6. public ListViewAdapter adapter;
7. public boolean isInit = true;
8. public String[] images = { "
28. public List<String> list = new ArrayList<String>();
29. public ListView listView;
30. public ImageView imageView;
31.
32. @Override
33. protected void onCreate(Bundle savedInstanceState) {
34. super.onCreate(savedInstanceState);
35. setContentView(R.layout.listview);
36. memoryCache = getLruCache();
37. for(int i = 0;i < 50;i++)
38. {
39. int index = i %(images.length);
40. list.add(images[index]);
41. }
42. listView = (ListView) findViewById(R.id.listView);
43. this);
44. null);
45. imageView = (ImageView) view.findViewById(R.id.imageView);
46. new ListViewAdapter(this, list, memoryCache, listView, imageView);
47. this);
48. listView.setAdapter(adapter);
49. }
50.
51. /**
52. * 获得LruCache对象
53. * @return
54. */
55. public LruCache<String, Bitmap> getLruCache()
56. {
57. null;
58. //获得可用的内存大小
59. int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);
60. //将其1/8设置成我们的内存缓存大小
61. int cacheSize = maxMemory/8;
62. new LruCache<String, Bitmap>(cacheSize){
63. @Override
64. protected int sizeOf(String key, Bitmap value) {
65. //返回当前图片的大小(getByteCount用于返回当前位图所占用的内存字节数)
66. return value.getByteCount() / 1024;
67. }
68. };
69. return cache;
70. }
71.
72. @Override
73. public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
74. start_index = firstVisibleItem;
75. end_index = start_index + visibleItemCount;
76. if(isInit == true && visibleItemCount > 0)
77. {
78. for(int i = start_index;i < end_index;i++)
79. {
80. adapter.loadImage(i);
81. }
82. false;
83. }
84. }
85. @Override
86. public void onScrollStateChanged(AbsListView view, int scrollState) {
87. if(scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE)
88. {
89. //表示停止滑动，这时候就可以加载图片
90. for(int i = start_index;i < end_index;i++)
91. {
92. adapter.loadImage(i);
93. }
94. else
95. {
96. adapter.cancelTask();
97. }
98. }
99. }Runtime.getRuntime().maxMemory()获得当前可用的内存大小，之后的cacheSize就是我们自己设置的LruCache所用的内存大小，第66行的sizeof方法用于返回当前图片的大小；
同样，类似于上一篇中DiskLruCache的使用，这里我们也设置了ListView的滑动事件，保证其在滑动的过程中不会进行加载图片的请求操作，滑动停止再去加载图片；
另外提示一句，不要忘记添加访问网络的权限：
1. <uses-permission android:name="android.permission.INTERNET"></uses-permission>点击下载源码！！！！！
我把上一篇博客和这篇的代码整合成了一个完整的带有DiskLruCache和LruCache缓存的ListView版本：
点击下载整合源码！！！！！
