本章的主题是Bitmap的加载和Cache，主要包含三个方面的内容。首先讲述如何有效地加载一个Bitmap，这是一个很有意义的话题，由于Bitmap的特殊性以及Android对单个应用所施加的内存限制，比如16MB，这导致Bitmap加载的适合很容易出现内存溢出。下面这个异常信息在开发种应该经常遇到：

因此如何高效的加载Bitmap是一个很重要也很容易被开发者或忽视的问题。

接着介绍Android中常用的缓存策略，缓存策略是一种通用的思想，可以用在很多场景中，但是实际开发中经常需要用Bitmap缓存。通过缓存策略，我们不需要每次都从网络上请求图片或者中设备中加载图片，这样就极大地提高了图片加载效率以及产品的用户体验。目前比较常用的缓存策略是LruCache和DiskLruCache，其中 LruCache常用用作内存缓存，而Disk LruCache常用用作存储缓存。Lru是Least Recently Used的所需，即使用最少使用算法，这中算法的核心思想为：当缓存快慢时，会淘汰最近最少使用的缓存目标，很显然Lru算法的思想时很容易被接受的。

最后本章会介绍如何优化列表的卡顿现象，ListView和GridView由于要加载大量的子视图，当用户款苏滑动时就很容易出现卡顿的现象，因此本章最后针对这个问题将会一一给出一些优化建议。

为了更好地介绍上述三个主题，本章提供了一个示例程序，该程序会尝试从网络加载大量图片，并在GridView中现实，可以发现这个程序具有很强的使用性，并且技术细节完全覆盖了本章的三个主题：图片加载、缓存策略、列表的滑动流程性，通过这个示例程序读者可以很好地理解本章地全部内容并能够在实际中灵活应用。

1.Bitmap的高效加载

在介绍Bitmap的高效加载之前，先说一下如何加载一个Bitmap，Bitmap在Android中指的是一张图片，可以是png格式也可以是jpg等其他常见格式。那么如何加载一个图片呢？BitmapFactory类提供了四类方法：decodeFile、decodeResource、decodeStream和decodeByteArray，分别用于支持文件系统、资源、输入流以及字节数组中加载出一个Bitmap对象，其中decodeFile和decodeResource又间接调用了decodeStream方法，这四类方法最终在Android底层实现的，对应着BitmapFactory类的几个native方法。

如何高效地加载Bitmap呢？其核心思想也很简单，那就是采用BitmapFactory.Options来加载所需尺寸那么大，这个时候把整个图片加载进来后设给ImageView，这显然是没有必要的，因为ImageView并没有办法现显示原始的图片。通过 BitmapFactory.Options就可以按照一定的采样率来加载缩小后的图片，将缩小后的图片在ImageView中显示，这样就会降低内存占用从而一定程度上避免OOM，提高了Bitmap加载时的性能。 BitmapFactory提供的加载图片的四类方法都支持 BitmapFactory.Options参数，通过它们就可以很方面的对一个图片进行采样缩放。

通过BitmapFactory.Options来缩放图片，主要是用到了它的inSampleSize参数，即采样率。当inSampleSize为1时，采样后的图片大小为图片的原始大小；当inSampleSize大于1时，比如为2，那么采样后的图片其宽高为原图大小的1/2，而像素为原图的1/4，其占有内存大小也为原图的1/4.拿一张1024*1024像素的图片来说，假定采用ARGB8888格式存储，它占有的内存为1024*1024*4，即4MB，如果inSampleSize为2，那么采样后的图片其内存占用只有512*512*4，即1MB。可以发现采样率inSampleSize必须大于1的正数图片才会有缩小的效果，并且采样率同时作用于宽高，这将导致缩放后的图片大小以采样率的2次方形式递减，即缩放比例为1/（inSampleSize的2次方），比如inSampleSize为4时，那么缩放比率为1/16.有一种特殊情况，那就是当inSampleSize小于1时，其作用相当于1，即无缩放效果。另外最新的官方文档中指出，inSampleSize的取值应该总是为2的指数，比如1、2、4、8、16等等。如果外界传递给系统的inSampleSize不为2的指数，那么系统会向下取整并选择一个最接近的2的指数来代替，比如3，系统会选择2来代替，但是经过验证发现这个结论并非在所有的Android版本上都成立，因此把它当成一个开发建议即可。

考虑以下实际情况，比如ImageView的大小是100*100像素，而图片的原始大小为200*200，那么只需要将采样率 inSampleSize设为2即可。但是如果图片大小为200*300呢？这个时候采样率还应该选择2，这样缩放后额大小为100*150像素，仍然是适合ImageView的，如果采样率为3，那么缩放后的图片大小就会小于ImageView所期望的大小，这样图片就会被拉伸从而导致模糊。

通过采样率即可有效地加载图片，那么到底如何获取采样率呢？获取采样率也很简单，遵循如下流程：

（1）将 BitmapFactory.Options的inJustDecodeBounds参数设为true并加载图片。

（2）从BitmapFactory.Options中取出图片的原始宽高，它们对应于outWidth和outHeight参数。

（3）根据采样率的规则并结合目标View的所需大小计算出采样率inSampleSize.

（4）将 BitmapFactory.Options的inJustDecodeBounds参数设为false，然后重写加载图片。

经过上面4个步骤，加载出的图片最终是缩放后的图片，当然也有可能不需要缩放。这里说明以下inJustDecodeBounds参数，当此参数设为true时，BitmapFactory只会解析图片的原始宽高信息，并不会去真正的加载图片，所以这个操作是轻量级的。另外需要注意的是，这个适合BitmapFactory获取的图片的宽高信息和图片的位置以及程序运行的设备有关，比如一张图片放在不同的drawable目录下或者运行在不同屏幕密度的设备上，这都可能导致BitmapFactory获取到不同的结果，之所以会出现这个现象，这和Android的资源加载机制有关。

将上面的四个流程用程序来实现，就产生了下面的代码：

    public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId, int reqWidth, int rewHeight){final BitmapFactory.Options options = new BitmapFactory.Options();options.inJustDecodeBounds = true;BitmapFactory.decodeResource(res,resId,options);options.inSampleSize = calculateInSampleSize(options, reqWidth, rewHeight);options.inJustDecodeBounds = true;return BitmapFactory.decodeResource(res,resId,options);}public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int rewHeight){final int height = options.outHeight;final int width = options.outWidth;int inSampleSize = 1;if (height > rewHeight || width > reqWidth) {final int halfHeight = height/2;final int haleWidth = width/2;while ((halfHeight / inSampleSize) >= rewHeight&& (haleWidth/inSampleSize) >= reqWidth){inSampleSize *= 2;}}return inSampleSize;}

有了上面的两个方法，实际使用的适合就很简单了，比如ImageView所期望的图片大小为100*100像素，这个时候就可以通过如下方式高效地加载并显示图片：

        mImageView.setImageBitmap(BitmapUtil.decodeSampledBitmapFromResource(getResources(),R.mipmap.ic_launcher,100,100));

除了BitmapFactory地decodeResource方法，其他三个decode系统地方法也是支持采样加载地，并且处理方式也是类似的，但是decodeStream方法稍微有点特殊，这个会在后续内容中详细介绍。通过本节的介绍，读者应该能很好地掌握这种高效地加载图片的方法了。

2. Android中的缓存策略

缓存策略在Android中有着广泛的应用场景，尤其在图片加载这个场景下，缓存策略就变得更为重要。考虑一种场景：有一批网络图片，需要下载后再用户界面上予以显示，这个场景再PC环境下是很简单的，直接把所有的图片下载到本地再显示即可，但是放到移动设备上就不一样了。不管是Android还是IOS设备，流量对于客户来说都是一种宝贵的资源，由于流量是收费的，所以在应用开发中并不能过多地消耗用户的流量，否则这个应用肯定不能被用户所接受。再加上目前国内公共场所的wifi的普及率并不算高，因此用户在很多情况下手机上都是用的移动网络而非wifi，因此必须提供一种解决方案来解决流量的消耗问题。

如何避免多多的流量消耗呢？那就是本节所要讨论的主题：缓存。当程序第一次网络加载图片后，就将其缓存到存储设备上，这样下次使用这张图片就不用再从网络上获取了，这样就为用户节省了流量。很多时候为了提高应用的用户体验，往往还会把图片放在内存中再缓存一份，这样当应用打算从网络上请求一张图片时，程序会首先从内存中去获取，如果内存中没有那就从存储设备中去获取。如果存储设备中也没有，那就从网络上下载这张图片。因为从内存中加载图片比从存储设备中加载图片要快，所以这样及提高了程序的效率又为用户节约了不必要的流量开销。上述的缓存策略不仅仅适用于图片，也适用于其他文件类型。

说到缓存策略，其实并没有统一的标准。一般来说，缓存策略主要包含缓存的添加、获取和删除这三类操作。如何添加和获取这个比较好理解，那为什么还要删除缓存呢？这是因为不管时内存缓存还是存储设备缓存，它们的缓存大小都是有限制的，因为内存和诸如SD卡之类的存储设备都是有容量限制的，因此再使用缓存时总是要为缓存指定一个最大的容量。如果当缓存容量满了，但是程序还需要向其添加缓存，这个时候该怎么办？这就需要删除一些旧的缓存并添加新的缓存，如何定义缓存的新旧这就是一种策略，不同的策略就对应着不同的缓存算法，比如可以简单地根据文件的最后修改时间来定义缓存的新旧，当缓存满时就将最后修改时间较早的缓存移除，这就是一种缓存算法，但是这种算法并不算很完美。

目前最常用的一种缓存算法是LRU，LRU是近期最少使用算法，它的核心思想是当缓存满时，会优先淘汰哪些近期最少使用的缓存对象。采样LRU算法的缓存有两种：LruCache和DiskLruCache， LruCache用于实现内存缓存，而DiskLruCache则充当了存储设备缓存，通过这二者的完美结合，就可以很方便地实现一个具有很高使用价值地ImageLoader。本节首先会介绍LruCache和DiskLruCache，然后利用LruCache和DiskLruCache来实现一个优秀地ImageLoader，并且提供一个使用ImageLoader来从网络下载并展示图片的例子，在这个例子种体现了ImageLoader以及大批量网络图片加载所设计的大量技术点。

2.1LruCache

LruCache是Android 3.1所提供的一个缓存类，通过support-v4兼容包到早期的Android版本，目前Android 2.2以下的用户量以及很少了，因此我们开发的应用兼容到Android 2.2就已经足够了。为了能够兼容Android 2.2版本，在使用LruCache时建议采用support-v4兼容包种的LruCache，而不是直接使用Android 3.1提供的LruCache。

LruCache是一个泛型类，它内部采用了一个LinkedHashMap以及强引用的方式存储外界的缓存对象，其提供了get和put方法来完成缓存的获取和添加操作，当缓存满时，LruCache会移除较早使用的缓存对象，然后再添加新的缓存对象。这里要明白强引用、软引用和弱引用的区别，如下所示。

强引用：直接的对象引用。

软引用：当一个对象只有软引用存在时，系统内存不足时此对象会被gc回收。

弱引用：当一个对象只有软引用存在时，此对象会随时被gc回收。

另外 LruCache是线程安全的。LruCache的实现比较简单，读者可以参考它的源码，这里仅介绍如何使用LruCache来实现内存缓存。仍然拿图片缓存的来举例子，下面的代码展示了LruCache的典型的初始化过程：

        int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);int cacheSize = maxMemory /8;mMemoryCache = new LruCache<String, Bitmap>(cacheSize){@Overrideprotected int sizeOf(String key, Bitmap bitmap) {return bitmap.getRowBytes() * bitmap.getHeight() / 1024;}};

在上面的代码种，只需要提供缓存的总容量大小并重写sizeof方法即可。sizeOf方法的作用是计算缓存对象的大小，这里的大小的单位需要和总容量的单位移植。对于上面的示例代码来说，总容量大小为当前进程可以内存的1/8，单位为KB，而sizeOf方法则完成了Bitmap对象的大小计算。很明显，之所以除以1024也是为了将其单位转换为KB。一些特殊情况下，还需要重写 LruCache的entryRemoved方法， LruCache移除就缓存时会调用 entryRemoved方法，因此可以在entryRemoved种完成一些资源回收工作。

除了 LruCache的创建外，还有缓存的获取和添加，这也很简单，从 LruCache获取一个缓存对象，如下所示。

mMemoryCache.get(key);

向 LruCache中添加一个缓存对象，如下所示。

mMemoryCache.put(key,bitmap);

LruCache还支持删除操作，通过remove方法即可删除一个指定的缓存对象。可以看到 LruCache的实现以及使用都非常简单，虽然简单，但是仍不影响它具有强大的功能。

2.2 DiskLruCache

Disk LruCache用于实现存储设备缓存，即磁盘缓存，它通过将缓存对象写入文件系统从而实现缓存的效果。DiskLruCache得到了Android官方文档的推荐，但它不属于Android SDK的一部分，它的源码请读者自行获取。

下面分别从 Disk LruCache的创建、缓存查找和缓存添加这三个方面来解释 Disk LruCache的使用方式。

1.DiskLruCache的创建

Disk LruCache并不能通过构造方法来创建，它提供了open方法用于创建自身，如下所示。

  public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)throws IOException

open方法有4个参数，其中第一个参数表示磁盘缓存在文件系统中的存储路径。缓存路径可以选择SD卡上的缓存目录，具体是指/sdcard/Android/data/package_name/cache目录，其中package_name表示当前应用的包名，当应用被卸载后，此目录一并被删除。当然也可以选择SD卡上的其他指定目录，还可以选择data下的当前应用的目录，具体可以根据需要灵活设定。这里给出一个建议：如果应该卸载后就希望删除缓存文件，那么就选择SD卡上的缓存目录，如果希望保留缓存数据，那就应该选择SD卡上的其他特定目录。

第二个参数表示应用的版本号，一般设为1即可。当版本号发送改变时 Disk LruCache会情况之前所有的缓存文件，而这个特性在实际开发中作用不大，很多情况下即使应用的版本号发送了改变缓存文件却仍然是有效的，因此这个参数设为1比较好。

第三个参数表示单个节点所对应的数据的个数，一般设为1即可。第4个参数表示缓存的总大小，比如50MB，当缓存大小超出这个设定值后， Disk LruCache会清楚一些缓存从而保证大小不大于这个设定值。下面是一个典型的 Disk LruCache的创建过程：

        File diskCacheDir = getDiskCacheDir(mContext, "bitmap");if (!diskCacheDir.exists()){diskCacheDir.mkdirs();}try {mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);} catch (IOException e) {e.printStackTrace();}

2.DiskLruCache的缓存添加

Disk LruCache的缓存添加的操作是通过Editor完成的，Editor表示一个缓存对象的编辑对象。这里仍然以图片缓存举例，首先火药获取url所对应的key，然后更具key就可以通过edit()来获取Editor对象，如果这个缓存正在被编辑，那么edit()会返回null，即 Disk LruCache不允许同时编辑一个缓存对象。之所以要把url转换成key，是因为图片url中很有可能存在特殊字符，这将影响url在Android中直接使用，一般采用url的md5作为key。如下所示。

    private String hashKeyFromUrl(String url){String cacheKey;try {final MessageDigest digest = MessageDigest.getInstance("MD5");digest.update(url.getBytes());cacheKey = bytesToHexString(digest.digest());} catch (NoSuchAlgorithmException e) {cacheKey = String.valueOf(url.hashCode());}return cacheKey;}private String bytesToHexString(byte[] bytes){StringBuilder sb = new StringBuilder();for (int i=0; i< bytes.length; i++) {String hex = Integer.toHexString(0xFF & bytes[i]);if (hex.length() == 1){sb.append("0");}sb.append(hex);}return sb.toString();}

将图片的url转成key以后，就可以获取Editor对象了。对于这个key来说，如果当前不存在其他Editor对象，那么edit()就会返回一个新的Editor对象，通过它就可以得到一个文件输出流。需要注意的是前面在 Disk LruCache的open方法中设置了一个节点只能有一个数据，因此下面的DISK_CACHE_INDEX常量直接设置为0即可，如下所示。

        String key = hashKeyFromUrl(url);try {DiskLruCache.Editor editor = mDiskLruCache.edit(key);if (editor != null) {OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);}} catch (IOException e) {e.printStackTrace();}

有了文件输出流，接下来要怎么做呢？其实是这也的，当从网络下载图片时，图片即可以通过这个文件输出流写入到文件系统上，这个过程的实现如下所示。

    private boolean downloadUrlToStream(String urlString, OutputStream outputStream){HttpURLConnection urlConnection = null;BufferedInputStream in = null;BufferedOutputStream out = null;try {final URL url = new URL(urlString);urlConnection = (HttpURLConnection)url.openConnection();in = new BufferedInputStream(urlConnection.getInputStream());out = new BufferedOutputStream(outputStream, IO_BUFFER_SIZE);int b;while ((b = in.read())!=-1){out.write(b);}return true;} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (urlConnection != null){urlConnection.disconnect();}MyUtils.close(out);MyUtils.close(in);}return false;}

经过上面的步骤，其实并没有真正的将图片写入文件系统，还必须通过Editor的commit()来提交写入操作，如果图片下载过程发送了异常，那么还可以通过Editor的abort()来回退整个操作，这个过程如下所示。

                OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);if (downloadUrlToStream(url, outputStream)){editor.commit();} else {editor.abort();}mDiskLruCache.flush();

经过上面的几个步骤，图片以及被正确地写入到文件系统了，接下来图片获得的操作就需要请求网络了。

3.DiskLruCache的缓存查找

和缓存添加过程类似，缓存查找也需要将url转换为key，然后通过DiskLruCache的get方法得到一个Snapshot对象，接着再通过Snapshot对象即可得到缓存文件的输出流，有了文件输出流，自然就可以得到Bitmap对象了。为了避免加载过程中导致的OOM问题，一般不建议直接加载原始图片。再1节中已经介绍了通过BitmapFactory.Options对象来加载一张缩放后的图片，但是那种方法对FileInputStream的缩放存在问题，原因是FileInputStream是一种有序的文件流，而两次decodeStream调用影响了文件流的位置属性，导致了第二次decodeStream时得到的是null。为了解决这个问题，可以通过文件流来得到它所对应的文件描述符，然后再通过BitmapFactory.decodeFileDescriptor方法来加载一张缩放后的图片，这个过程实现如下所示。

        Bitmap bitmap = null;String key = hashKeyFromUrl(url);try {DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);if (snapshot != null) {FileInputStream fileInputStream = (FileInputStream)snapshot.getInputStream(DISK_CACHE_INDEX);FileDescriptor descriptor = fileInputStream.getFD();bitmap = BitmapUtil.decodeSampledBitmapFromFileDescriptor(descriptor,reqWidth,rewHeight);if (bitmap != null){addBitmapToMemoryCache(key,bitmap);}}} catch (IOException e) {e.printStackTrace();}return bitmap;

上面介绍了 Disk LruCache的创建、缓存的添加过和查找过程，读者应该对 Disk LruCache的使用方式有了一个大致的了解，除此之外， Disk LruCache还提供了remove、delete等方法用于磁盘缓存的删除操作。关于 Disk LruCache的内部实现这里就不再介绍了，感兴趣的朋友可以查看它的源码实现。

2.3 ImageLoader的实现

在本章的前面先后介绍了Bitmap的高效加载方式、LruCache以及 Disk LruCache，现在我们来着手实现一个优秀的ImageLoader。

一般来说，一个优秀的ImageLoader应该具备如下功能：

图片的同步加载、图片的异步加载、图片压缩、内存缓存、磁盘缓存、网络拉取。

图片的同步加载是指能够以同步的方式向调用者提供锁甲在的图片，这个图片可能是从内存中读取的，也可能是从磁盘缓存中读取的，还可能使从网络拉取的。图片的异步加载时一个很有用的功能，很多时候调用者不想再单独的线程中已同步的方式来获取图片，这个时候ImageLoader内部需要自己在线程中加载图片并将图片设置给所需的ImageView。图片压缩的作用更毋庸置疑了，这是降低OOM概率的有效手段，ImageLoader必须合适地处理图片的压缩问题。

内存缓存和磁盘缓存时 ImageLoader的核心，也是 ImageLoader的意义所在，通过这两集缓存极大地提高了程序的效率并且有效地降低了对用户造成地流量消耗，只有当这两级缓存都不可以时才需要从网络中拉取图片。

除此之外， ImageLoader还需要处理一些特殊情况，比如在ListView或者GridView中，View复用既是它们的有点也是它们的缺点，有点想必应该都清楚了，那缺点可能还不太清楚。考虑一种情况，在 ListView或者GridView中，假设一个item A 正在从网络加载图片，它对应的ImageView为A，这个时候用户快速地向下滑动列表，很可能item B复用了ImageView A，然后等了一会之前的图片下载完毕了。如果直接给ImageView A设置图片，由于这个时候ImageView A被item B所复用，但是item B显然不是item A刚刚下载好的图片，这个时候会出现B中显示了A的图片，这就是常见的列表的错位问题，ImageLoader需要正确地处理这些特殊情况。

上面对ImageLoader的功能做了一个全面的分析，下面就可以一步步实现ImageLoader了，这里主要分为如下几步。

1.图片的压缩功能的实现

图片压缩在1节中已经做了介绍，这里就不再多说了，为了有良好的设计风格，这里单独抽象了一个类用于完成图片的压缩功功能，这个类叫ImageResizer，它的实现如下所示。

public class ImageResizer {public ImageResizer() {}public Bitmap decodeSampledBitmapFromFileDescriptor(FileDescriptor descriptor, int reqWidth, int rewHeight ){final BitmapFactory.Options options = new BitmapFactory.Options();options.inJustDecodeBounds = true;BitmapFactory.decodeFileDescriptor(descriptor, null,options);options.inSampleSize = calculateInSampleSize(options, reqWidth, rewHeight);options.inJustDecodeBounds = false;return BitmapFactory.decodeFileDescriptor(descriptor, null,options);}public Bitmap decodeSampledBitmapFromResource(Resources res, int resId, int reqWidth, int rewHeight){final BitmapFactory.Options options = new BitmapFactory.Options();options.inJustDecodeBounds = true;BitmapFactory.decodeResource(res,resId,options);options.inSampleSize = calculateInSampleSize(options, reqWidth, rewHeight);options.inJustDecodeBounds = false;return BitmapFactory.decodeResource(res,resId,options);}public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int rewHeight){if (reqWidth == 0 || rewHeight == 0) {return 1;}final int height = options.outHeight;final int width = options.outWidth;int inSampleSize = 1;if (height > rewHeight || width > reqWidth) {final int halfHeight = height/2;final int haleWidth = width/2;while ((halfHeight / inSampleSize) >= rewHeight&& (haleWidth/inSampleSize) >= reqWidth){inSampleSize *= 2;}}return inSampleSize;}
}

2.内存缓存和磁盘缓存的实现

这里选择LruCache和Disk LruCache来分贝完成内存缓存和磁盘缓存的工作。在ImageLoader初始化时，会创建 LruCache和Disk LruCache，如下所示。

    private LruCache<String, Bitmap> mMemoryCache;private DiskLruCache mDiskLruCache;public ImageLoader(Context context) {mContext = context.getApplicationContext();int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);int cacheSize = maxMemory /8;mMemoryCache = new LruCache<String, Bitmap>(cacheSize){@Overrideprotected int sizeOf(String key, Bitmap bitmap) {return bitmap.getRowBytes() * bitmap.getHeight() / 1024;}};File diskCacheDir = getDiskCacheDir(mContext, "bitmap");if (!diskCacheDir.exists()){diskCacheDir.mkdirs();}if (getUsableSpace(diskCacheDir) > DISK_CACHE_SIZE) {try {mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);mIsDiskLruCacheCreated = true;} catch (IOException e) {e.printStackTrace();}}}

在创建磁盘缓存时，这里做了判断，即有可能磁盘剩余空间小于磁盘缓存所需的大小，一般是指用户的手机空间已经不足了，因此没有办法创建磁盘缓存，这个时候磁盘缓存就会失效。在上面的海马实现中，ImageLoader的内存缓存容量为当前进程可用内存的1/8，磁盘缓存的容量是50MB。

内存缓存和磁盘缓存创建完毕后，还需要提高方法来完成缓存的添加和获取功能。首先看内存缓存，它的添加和读取过程比较简单，如下所示。

    private Bitmap getBitmapFromMemoryCache(String key){return mMemoryCache.get(key);}private void addBitmapToMemoryCache(String key, Bitmap bitmap){if (getBitmapFromMemoryCache(key) == null) {mMemoryCache.put(key, bitmap);}}

而磁盘缓存和读取功能稍微复杂一些，具体内容已经在2.2节中进行了详细的介绍，这里再简单说明一下。磁盘缓存的添加需要通过Editor来完成， Editor提高了commit和abort方法来提交和撤销对文件系统的写操作，具体实现请参看下面的loadBitmapFromHttp方法。磁盘缓存的读取需要通过Snapshot来完成，通过Snapshot可以得到磁盘缓存对象对应的FileInputStream，但是 FileInputStream无法边界的进行压缩，所以通过FileDescriptor来加载压缩后的图片，最后将加载后的Bitmap添加到内存中，具体实现请参考下面的loadBitmapFromDiskCache方法。

    private Bitmap loadBitmapFromDiskCache(String url,int reqWidth, int rewHeight) throws IOException{if (Looper.myLooper() == Looper.getMainLooper()){throw new RuntimeException("can not visit network from UI thread.");}if (mDiskLruCache == null){return null;}Bitmap bitmap = null;String key = hashKeyFromUrl(url);DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);if (snapshot != null) {FileInputStream fileInputStream = (FileInputStream)snapshot.getInputStream(DISK_CACHE_INDEX);FileDescriptor descriptor = fileInputStream.getFD();bitmap = mImageResizer.decodeSampledBitmapFromFileDescriptor(descriptor,reqWidth,rewHeight);if (bitmap != null){addBitmapToMemoryCache(key,bitmap);}}return bitmap;}private Bitmap loadBitmapFromHttp(String url,int reqWidth, int rewHeight)throws IOException{if (Looper.myLooper() == Looper.getMainLooper()){throw new RuntimeException("can not visit network from UI thread.");}if (mDiskLruCache == null){return null;}String key = hashKeyFromUrl(url);DiskLruCache.Editor editor = mDiskLruCache.edit(key);if (editor != null) {OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);if (downloadUrlToStream(url, outputStream)){editor.commit();} else {editor.abort();}mDiskLruCache.flush();}return loadBitmapFromDiskCache(url, reqWidth, rewHeight);}

3.同步加载和异步加载的接口设计

首先看同步加载，同步加载接口需要外部在线程中调用，这是因为同步很可能比较耗时，它的实现如下所示。

    public Bitmap loadBitmap(String url,int reqWidth, int rewHeight){Bitmap bitmap = loadBitmapFromMemoryCache(url);if (bitmap != null) {return bitmap;}try {bitmap = loadBitmapFromDiskCache(url,reqWidth,rewHeight);if (bitmap != null) {return bitmap;}bitmap = loadBitmapFromHttp(url,reqWidth,rewHeight);} catch (IOException e) {e.printStackTrace();}if (bitmap == null && !mIsDiskLruCacheCreated) {bitmap = downloadFromUrl(url);}return bitmap;}

从loadBitmap的实现可以看出，其工作过程遵循如下几步：首先尝试从内存中读取图片，接着尝试从磁盘缓存中读取图片，最后才从网络中拉取图片。另外，这个方法不能在主线程中调用，否则就会抛出异常。这个执行换下的检查时在loadBitmapFromHttp中实现的，通过检测当前线程的Looper是否为主线的Looper来判断当前线程是否是主线程，如果不是主线程就直接抛出异常终止程序，如下所示。

        if (Looper.myLooper() == Looper.getMainLooper()){throw new RuntimeException("can not visit network from UI thread.");}

接着看异步加载接口的设计，如下所示。

    public void bindBitmap(final String uri, final ImageView imageView,final int reqWidth, final int reqHeight){imageView.setTag(TAG_KEY_URI, uri);final Bitmap bitmap = loadBitmapFromMemoryCache(uri);if (bitmap != null) {imageView.setImageBitmap(bitmap);return;}final Runnable loadBitmapTask = new Runnable() {@Overridepublic void run() {Bitmap bitmap1 = loadBitmap(uri,reqWidth,reqHeight);if (bitmap1 != null) {LoaderResult result = new LoaderResult(imageView, uri, bitmap);mMainHandler.obtainMessage(MESSAGE_POST_RESULT, result).sendToTarget();}}};THREAD_POOL_EXECUTOR.execute(loadBitmapTask);}

从bindBitmap的实现来看，bindBitmap方法会尝试从内存缓存中读取图片，如果读取成功就直接返回，否则会在线程池中去调用loadBitmap方法，当图片加载成功后再将图片、图片地址已经需要绑定的ImageView封装成一个LoadResult对象，然后再通过mMainHandler向主线程发送一个消息，这也就可以在主线程中给ImageView设置图片了，之所以通过Handler来中专是因为子线程无法访问UI。

bindBitmap中用到了线程池和Handler，这里看一下它们的实现，首先看线程池THREAD_POOL_ECECUTOR的实现，如下所示。可以看出它的核心线程数为当前设备的CPU核心数+1，最大容量为CPU核心数的2倍加1，线程闲置超时时长为10秒，关于线程池的解释可以看11章节的内容。

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();private static final int CORE_POOL_SIZE = CPU_COUNT + 1;private static final int MAX_POOL_SIZE = CPU_COUNT*2 + 1;private static final long KEEP_ALIVE = 10L;    private static final ThreadFactory sThreadFactory = new ThreadFactory() {private final AtomicInteger mCount = new AtomicInteger(1);@Overridepublic Thread newThread(@NonNull Runnable r) {return new Thread(r, "ImageLoader#" + mCount.getAndIncrement());}};public static final Executor THREAD_POOL_EXECUTOR =new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE, TimeUnit.SECONDS,new LinkedBlockingDeque<Runnable>(), sThreadFactory);

之所以采用线程池是有原因的，首先肯定不能采用普通的线程去做这个事，线程池的好处在11章已经做了详细的说明。如果直接采用普通的线程去加载图片，随着列表的滑动这可能会产生大量的线程，这也并不利于整体效率的提示。另外一点，这里也没有选择采用AsyncTask， AsyncTask封装了线程池和Handler，按道理它应该最适合ImageLoader的场景。从11章对 AsyncTask的分析可以知道， AsyncTask在3.0的低版本和高版本上具有不同的表现，在3.0以上的版本 AsyncTask无法实现并发效果，这显然是不能接受的，因为ImageLoader需要并发现，虽然可以通过改造 AsyncTask或者使用 AsyncTask的executeExecutor方式的形式来执行异步任务，但是这最终不是太自然的实现方式。鉴于以上两点原因，这里选择线程池和Handler来提高ImageLoader的并发能力和访问UI的能力。

分析完线程的选择，下面看一下Handler的实现，如下所示。ImageLoader直接采用主线程的Looper来构造Handler对象，这就使得ImageLoader可以在非主线程中构造了。另外为了解决由于View复用所导致的列表错位的这一问题，在给ImageView设置图片之前都会检查它的url有没有发生改变，如果发送改变就不再给他设置图片，这样就解决了列表的错位问题。

    private Handler mMainHandler = new Handler(Looper.getMainLooper()){@Overridepublic void handleMessage(Message msg) {LoaderResult result = (LoaderResult) msg.obj;ImageView imageView = result.imageView;String uri = (String) imageView.getTag();if (uri.equals(result.uri)){imageView.setImageBitmap(result.bitmap);} else {Log.d(TAG, "set image bitmap, but uri has changed,ignored!");}}};

到此为止，ImageLoader的细节都已经做了全面的分析，下面是ImageLoader的完整代码。

public class ImageLoader {private static final String TAG= "ImageLoader";private static final int MESSAGE_POST_RESULT = 1;private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();private static final int CORE_POOL_SIZE = CPU_COUNT + 1;private static final int MAX_POOL_SIZE = CPU_COUNT*2 + 1;private static final long KEEP_ALIVE = 10L;private static final int IO_BUFFER_SIZE = 8 * 1024;private static final int TAG_KEY_URI = R.id.imageloader_url;private static final long DISK_CACHE_SIZE = 1024 * 1024 *50;private static final int DISK_CACHE_INDEX = 0;private boolean mIsDiskLruCacheCreated = false;private static final ThreadFactory sThreadFactory = new ThreadFactory() {private final AtomicInteger mCount = new AtomicInteger(1);@Overridepublic Thread newThread(@NonNull Runnable r) {return new Thread(r, "ImageLoader#" + mCount.getAndIncrement());}};public static final Executor THREAD_POOL_EXECUTOR =new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE, TimeUnit.SECONDS,new LinkedBlockingDeque<Runnable>(), sThreadFactory);private Handler mMainHandler = new Handler(Looper.getMainLooper()){@Overridepublic void handleMessage(Message msg) {LoaderResult result = (LoaderResult) msg.obj;ImageView imageView = result.imageView;String uri = (String) imageView.getTag();if (uri.equals(result.uri)){imageView.setImageBitmap(result.bitmap);} else {Log.d(TAG, "set image bitmap, but uri has changed,ignored!");}}};private Context mContext;private LruCache<String, Bitmap> mMemoryCache;private DiskLruCache mDiskLruCache;private ImageResizer mImageResizer;private ImageLoader(Context context) {mImageResizer = new ImageResizer();mContext = context.getApplicationContext();int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);int cacheSize = maxMemory /8;mMemoryCache = new LruCache<String, Bitmap>(cacheSize){@Overrideprotected int sizeOf(String key, Bitmap bitmap) {return bitmap.getRowBytes() * bitmap.getHeight() / 1024;}};File diskCacheDir = getDiskCacheDir(mContext, "bitmap");if (!diskCacheDir.exists()){diskCacheDir.mkdirs();}if (getUsableSpace(diskCacheDir) > DISK_CACHE_SIZE) {try {mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);mIsDiskLruCacheCreated = true;} catch (IOException e) {e.printStackTrace();}}}public static ImageLoader build(Context context){return new ImageLoader(context);}private Bitmap getBitmapFromMemoryCache(String key){return mMemoryCache.get(key);}private void addBitmapToMemoryCache(String key, Bitmap bitmap){if (getBitmapFromMemoryCache(key) == null) {mMemoryCache.put(key, bitmap);}}public void bindBitmap(final String uri, final ImageView imageView){bindBitmap(uri,imageView,0,0);}public void bindBitmap(final String uri, final ImageView imageView,final int reqWidth, final int reqHeight){imageView.setTag(TAG_KEY_URI, uri);final Bitmap bitmap = loadBitmapFromMemoryCache(uri);if (bitmap != null) {imageView.setImageBitmap(bitmap);return;}final Runnable loadBitmapTask = new Runnable() {@Overridepublic void run() {Bitmap bitmap1 = loadBitmap(uri,reqWidth,reqHeight);if (bitmap1 != null) {LoaderResult result = new LoaderResult(imageView, uri, bitmap);mMainHandler.obtainMessage(MESSAGE_POST_RESULT, result).sendToTarget();}}};THREAD_POOL_EXECUTOR.execute(loadBitmapTask);}public Bitmap loadBitmap(String url,int reqWidth, int rewHeight){Bitmap bitmap = loadBitmapFromMemoryCache(url);if (bitmap != null) {return bitmap;}try {bitmap = loadBitmapFromDiskCache(url,reqWidth,rewHeight);if (bitmap != null) {return bitmap;}bitmap = loadBitmapFromHttp(url,reqWidth,rewHeight);} catch (IOException e) {e.printStackTrace();}if (bitmap == null && !mIsDiskLruCacheCreated) {bitmap = downloadFromUrl(url);}return bitmap;}private Bitmap loadBitmapFromMemoryCache(String url){final String key = hashKeyFromUrl(url);return getBitmapFromMemoryCache(key);}private Bitmap loadBitmapFromHttp(String url,int reqWidth, int rewHeight)throws IOException{if (Looper.myLooper() == Looper.getMainLooper()){throw new RuntimeException("can not visit network from UI thread.");}if (mDiskLruCache == null){return null;}String key = hashKeyFromUrl(url);DiskLruCache.Editor editor = mDiskLruCache.edit(key);if (editor != null) {OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);if (downloadUrlToStream(url, outputStream)){editor.commit();} else {editor.abort();}mDiskLruCache.flush();}return loadBitmapFromDiskCache(url, reqWidth, rewHeight);}private Bitmap loadBitmapFromDiskCache(String url,int reqWidth, int rewHeight) throws IOException{if (Looper.myLooper() == Looper.getMainLooper()){throw new RuntimeException("can not visit network from UI thread.");}if (mDiskLruCache == null){return null;}Bitmap bitmap = null;String key = hashKeyFromUrl(url);DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);if (snapshot != null) {FileInputStream fileInputStream = (FileInputStream)snapshot.getInputStream(DISK_CACHE_INDEX);FileDescriptor descriptor = fileInputStream.getFD();bitmap = mImageResizer.decodeSampledBitmapFromFileDescriptor(descriptor,reqWidth,rewHeight);if (bitmap != null){addBitmapToMemoryCache(key,bitmap);}}return bitmap;}private boolean downloadUrlToStream(String urlString, OutputStream outputStream){HttpURLConnection urlConnection = null;BufferedInputStream in = null;BufferedOutputStream out = null;try {final URL url = new URL(urlString);urlConnection = (HttpURLConnection)url.openConnection();in = new BufferedInputStream(urlConnection.getInputStream());out = new BufferedOutputStream(outputStream, IO_BUFFER_SIZE);int b;while ((b = in.read())!=-1){out.write(b);}return true;} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (urlConnection != null){urlConnection.disconnect();}MyUtils.close(out);MyUtils.close(in);}return false;}private Bitmap downloadFromUrl(String urlString){Bitmap bitmap = null;HttpURLConnection urlConnection = null;BufferedInputStream in = null;try {final URL url = new URL(urlString);urlConnection = (HttpURLConnection)url.openConnection();in = new BufferedInputStream(urlConnection.getInputStream());bitmap = BitmapFactory.decodeStream(in);} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (urlConnection != null) {urlConnection.disconnect();}MyUtils.close(in);}return bitmap;}private String hashKeyFromUrl(String url){String cacheKey;try {final MessageDigest digest = MessageDigest.getInstance("MD5");digest.update(url.getBytes());cacheKey = bytesToHexString(digest.digest());} catch (NoSuchAlgorithmException e) {cacheKey = String.valueOf(url.hashCode());}return cacheKey;}private String bytesToHexString(byte[] bytes){StringBuilder sb = new StringBuilder();for (int i=0; i< bytes.length; i++) {String hex = Integer.toHexString(0xFF & bytes[i]);if (hex.length() == 1){sb.append("0");}sb.append(hex);}return sb.toString();}private File getDiskCacheDir(Context context, String name) {boolean externalStorageAvailable = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);final  String cachePath;if (externalStorageAvailable){cachePath = context.getExternalCacheDir().getPath();} else {cachePath = context.getCacheDir().getPath();}return new File(cachePath + File.separator + name);}@TargetApi(Build.VERSION_CODES.GINGERBREAD)private long getUsableSpace(File path){if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD){return  path.getUsableSpace();}final StatFs stats = new StatFs(path.getPath());return (long)stats.getBlockSize() * (long)stats.getAvailableBlocks();}private static class LoaderResult {public  ImageView imageView;public  String uri;public  Bitmap bitmap;public LoaderResult(ImageView imageView, String uri, Bitmap bitmap) {this.imageView = imageView;this.uri = uri;this.bitmap = bitmap;}}
}

3.ImageLoader的使用

在2.3节中我们实现了一个完整功能的 ImageLoader，本节将演示如何通过 ImageLoader来实现一个照片强的效果，实际上我们会发现，通过 ImageLoader打造一个照片墙是轻而易举的事情。最后针对如何提高列表流程都这个问题，本节会给出一些针对性的建议供读者参考。

3.1照片强效果

实现照片强效果需要用到GridView，下面先准备好GridView所需的布局文件以及item的布局文件，如下所示。

#GridView的的布局文件
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"android:layout_height="match_parent"tools:context="study.chenj.chapter_9.TestActivity"><GridViewandroid:id="@+id/gridView1"android:layout_width="match_parent"android:layout_height="match_parent"android:gravity="center"android:horizontalSpacing="5dp"android:verticalSpacing="5dp"android:listSelector="@android:color/transparent"android:numColumns="3"android:stretchMode="columnWidth"/>
</LinearLayout>#GridView的item的布局文件
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent"android:layout_height="wrap_content"android:gravity="center"android:orientation="vertical"><study.chenj.chapter_9.SquareImageViewandroid:id="@+id/image"android:scaleType="centerCrop"android:src="@mipmap/ic_launcher"android:layout_width="match_parent"android:layout_height="wrap_content" />
</LinearLayout>

GridView的item的布局文件中并没有采用ImageView，而是采用了一个叫SquareImageView的自定义控件。顾名思义，它的作用就是打造一个正方形的ImageView，这样整个照片墙看起来会比较整齐美观。需要实现一个宽高相等的ImageView是非常简单的是一件事，只需要在onMeasure方法中稍微处理一下，如下所示。

public class SquareImageView extends android.support.v7.widget.AppCompatImageView {public SquareImageView(Context context) {super(context);}public SquareImageView(Context context, @Nullable AttributeSet attrs) {super(context, attrs);}public SquareImageView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {super(context, attrs, defStyleAttr);}@Overrideprotected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {super.onMeasure(widthMeasureSpec, widthMeasureSpec);}
}

可以看出，我们在SquareImageView的onMeasure方法中很巧妙地将heightMeasureSpec替换为widthMeasureSpec，这一什么都不用做就可以一个宽高相等的ImageView了。关于View的测量过程在前面已经结束过了。

接着需要实现一个BaseAdapter给GridView使用，下面的代码展示了ImageAdapter的实现细节，其中mUrList中存储的是图片的url：

public class ImageAdapter extends BaseAdapter {...@Overridepublic int getCount() {return mUrList.size();}@Overridepublic Object getItem(int position) {return mUrList.get(position);}@Overridepublic long getItemId(int position) {return position;}@Overridepublic View getView(int position, View convertView, ViewGroup parent) {ViewHolder holder = null;if (convertView == null){convertView = LayoutInflater.from(mContext).inflate(R.layout.grid_item,parent,false);holder = new ViewHolder();holder.imageView = (ImageView)convertView.findViewById(R.id.image);convertView.setTag(holder);} else {holder = (ViewHolder)convertView.getTag();}ImageView imageView = holder.imageView;final String tag = (String)imageView.getTag();final String url = (String)getItem(position);if (!url.equals(tag)){imageView.setImageDrawable(mDefaultBitmapDrawable);}if (mIsGridViewIdle && mCanGetBitmapFromNetWork){imageView.setTag(url);mImageLoader.bindBitmap(url,imageView,mImageWidth, mImageWidth);}return convertView;}}

从上述代码来看，ImageAdapter的实现过程非常简捷，这几乎是最简洁的BaseAdapter的实现了。但是简洁并不等于简单，getView方法中核心代码只有一句，那就是：mImageLoader.bindBitmap(url,imageView,mImageWidth, mImageWidth).

通过bindBitmap方法很轻松地将复杂的图片加载过程交给了ImageLoader， ImageLoader加载图片以后会把图片自动设置给imageView，而整个过程，包括内存缓存、磁盘缓存一句图片压缩等工作过程对ImageAdapter来说都是透明的。在这张设计思想下， ImageAdapter也不需要知道，因此这是一个轻量级的 ImageAdapter。

接着将 ImageAdapter设置给GridView，如下所示。到此为止一个绚丽的图片墙就大功告成了，是不是惊叹于如此简洁而又优美的实现过程呢？

        GridView gridView = (GridView)findViewById(R.id.gridView1);gridView.setAdapter(new ImageAdapter(this,getUrls()));

最后看一下我们亲手打造的图片墙的效果图，是不是看起来很优美呢？

3.2 优化列表的卡顿现象

这个问题困扰了很多开发者，其实答案很简单，不要在主线程中做太多的耗时的操作即可提高滑动的流畅度，可以从三个方面来说。

首先，不要再getView中执行耗时操作。对于上面的例子来说，如果直接再getView中加载图片，肯定会导致卡顿，加载图片是一个耗时的操作，这张操作必须通过异步的方式来处理，就像ImageLoader实现的那样。

其次，控制异步的任务执行频率。这一点也很重要，对于列表来说，仅仅再getView中采用异步是不够的。考虑一种情况，以照片墙来说，在getView方法中会通过ImageLoader的bindBitmap方法来异步加载图片，但是如果用户可以频繁上下滑动，这就会在一瞬间产生上百个异步任务，这些异步任务会造成线程池的拥堵并随即带来大量的UI更新操作，这是没有意义的。由于一瞬间存在大量的UI操作，这些UI操作是运行在主线程的，这就会造成一定的卡顿现象。如何解决这个问题呢？可以考虑在滑动的时候停止加载图片，尽管这个过程是异步的，等列表停下来以后再加载图片仍然可以获得良好的用户体验。具体实现时，可以给ListView或者GridView设置setOnScrollListener，并在 setOnScrollListener的onScrollStateChanged方法中判断列表是否处于滑动状态，如果是的话，就停止加载图片，如下所示。

            public void onScrollStateChanged(AbsListView view, int scrollState) {if (scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE){mIsGridViewIdle = true;ImageAdapter.this.notifyDataSetChanged();} else {mIsGridViewIdle = false;}}

然后在getView方法中，仅当列表静止时才能加载图片，如下所示。

        if (mIsGridViewIdle){imageView.setTag(url);mImageLoader.bindBitmap(url,imageView,mImageWidth, mImageWidth);}

一般来说经过上面两个步骤，列表都不会有卡顿现象，但是在某些特殊情况下，列表还是会有偶尔卡顿线程，这个时候还可以开启硬件加速。绝大多说情况下，硬件加速可以解决莫名的卡顿问题，通过设置android:hardwareAccelerated="true"即可为Activity开启硬件加速。

Bitmap的加载和Cache相关推荐

《Android开发艺术探索》第12章- Bitmap 的加载和 Cache 读书笔记
目录 1. 前言 2. 正文 2.1 Bitmap 的高效加载 2.1.1 说一下对于Android 中的 Bitmap 的理解 2.1.2 内存中存储的 Bitmap 对象和本地图片有什么区别? 2 ...
《android开发艺术探索》笔记之Bitmap的加载和Cache
<Android开发艺术探索>笔记之Bitmap的加载和Cache<一> 我放暑假前,就在图书馆借了一本<Android开发艺术探索>,这也是我看到很多人推荐的.之 ...
Connor学Android - Bitmap的加载和缓存策略
Learn && Live 虚度年华浮萍于世,勤学善思至死不渝前言 Hey,欢迎阅读Connor学Android系列,这个系列记录了我的Android原理知识学习.复盘过程,欢迎各位 ...
Android开发-自己动手写Bitmap高效加载跟OOM说再见
Bitmap 前言 BitmapFactory.Options BitmapFactory 高效加载Bitmap inDensity,inTargetDensity,inScaled inSample ...
高效使用Bitmaps（一）大Bitmap的加载
转自:http://my.oschina.net/rengwuxian/blog/182885 高效使用Bitmaps有什么好处? 我们常常提到的"Android程序优化",通常 ...
Bitmap高效加载
1.Bitmap的基础概念 Bitmap是Android系统中的图像处理的最重要类之,Bitmap可以获取图片的信息,可以将信息进行缩放,裁剪等操作,提供了图片文件的操作支持. 2.Bitmap加载方 ...
安卓 Bitmap 高效加载
博客: 安卓之家微博: 追风917 CSDN: 蒋朋的家简书: 追风917 理论 Bitmap 的高效加载会利用 BitmapFactory.Options 来加载所需尺寸的图片,也就是可以按一定 ...
Bitmap如何高效加载图片
如何高效加载Bitmap? 核心思想:利用BitmapFactory.Obtions来加载所需尺寸的图片. BitmapFactory.Obtions主要用到它的inSampleSize参数(采样率) ...
Universal-imageLoader缓存图片加载
一,先要配置ImageLoaderConfiguration这个类实现全局ImageLoader的实现情况 ImageLoaderConfiguration config = new ImageLoa ...

Bitmap的加载和Cache