1 BitmapFactory.Options options = new BitmapFactory.Options();
 2         //这个属性设置为true就是deocde的时候 返回的bitmap是null，但是这种decode方法
 3         //无论你原始图片有多大，哪怕是一亿像素 都不会oom！他的作用就是可以利用这个属性
 4         //去读取你原始图片的信息，注意是原始图片，而不是系统加载过的图片，我们都知道
 5         //如果你把一张图片放在mdpi的下面，手机是xxhdpi的话 图片在显示的过程中会自动放大
 6         //但是在这里用这个属性的时候 是不care 你图片放在哪个路径下的，也不care你手机的dpi
 7         //他就只单纯的关心原始图片的原始属性
 8         options.inJustDecodeBounds = true;
 9         BitmapFactory.decodeResource(getResources(), R.mipmap.dd
10                 , options);
11         //原始图片的宽高。
12         int height = options.outHeight;
13         int width = options.outWidth;
14         //这个按照通俗的理解就是 把图片的后缀名告诉你 比如jpeg png 这种
15         String imageType = options.outMimeType;

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:id="@+id/root"android:layout_margin="30dp"android:layout_width="match_parent"android:layout_height="match_parent"android:background="@android:color/holo_red_light"tools:context=".MainActivity"><ImageViewandroid:layout_width="10dp"android:layout_height="10dp"android:id="@+id/iv"android:src="@drawable/gg"/></FrameLayout>

public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,int reqWidth, int reqHeight) {// 先把inJustDecodeBounds设置为true 取得原始图片的属性final BitmapFactory.Options options = new BitmapFactory.Options();options.inJustDecodeBounds = true;BitmapFactory.decodeResource(res, resId, options);// 然后算一下我们想要的最终的属性options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);// 在decode的时候 别忘记直接 把这个属性改为false 否则decode出来的是nulloptions.inJustDecodeBounds = false;return BitmapFactory.decodeResource(res, resId, options);}public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {// 先从options 取原始图片的 宽高final int height = options.outHeight;final int width = options.outWidth;int inSampleSize = 1;if (height > reqHeight || width > reqWidth) {final int halfHeight = height / 2;final int halfWidth = width / 2;//一直对这个图片进行宽高 缩放，每次都是缩放1倍，然后这么叠加，当发现叠加以后 也就是缩放以后的宽或者高小于我们想要的宽高//这个缩放就结束 跳出循环 然后就可以得到我们极限的inSampleSize值了。while ((halfHeight / inSampleSize) > reqHeight&& (halfWidth / inSampleSize) > reqWidth) {inSampleSize *= 2;}}return inSampleSize;}

1  iv=(ImageView)this.findViewById(R.id.iv);
2         //这种加载方式最终我们的app 占用内存大小仅仅是9.85mb左右，而下面那个注释掉的加载方式，就和你在xml里直接写id的方式是一样的
3         //占用内存将近50mb！
4         iv.setImageBitmap(decodeSampledBitmapFromResource(getResources(),R.drawable.gg,20,20));
5         //iv.setImageBitmap(BitmapFactory.decodeResource(getResources(),R.drawable.gg));

 1  class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
 2         private final ImageView iv;
 3         private int data = 0;
 4
 5         public BitmapWorkerTask(ImageView imageView) {
 6             iv = imageView;
 7         }
 8
 9         // Decode image in background.
10         @Override
11         protected Bitmap doInBackground(Integer... params) {
12             data = params[0];
13             return decodeSampledBitmapFromResource(getResources(), data, 500, 500);
14         }
15
16         @Override
17         protected void onPostExecute(Bitmap bitmap) {
18             iv.setImageBitmap(bitmap);
19         }
20     }

 1  class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
 2         private final WeakReference<ImageView> imageViewReference;
 3         private int data = 0;
 4
 5         public BitmapWorkerTask(ImageView imageView) {
 6             // 用弱引用来关联这个imageview。大家一定要记住，弱引用是避免android 在各种callback回调里发生内存泄露的最佳方法！
 7             //而软引用则是做缓存的最佳方法 两者不要搞混了！
 8             imageViewReference = new WeakReference<ImageView>(imageView);
 9         }
10
11         // Decode image in background.
12         @Override
13         protected Bitmap doInBackground(Integer... params) {
14             data = params[0];
15             return decodeSampledBitmapFromResource(getResources(), data, 100, 100);
16         }
17
18         @Override
19         protected void onPostExecute(Bitmap bitmap) {
20             //当你background线程跑完以后 先看看imageview还在不在，不在 就什么也不做 等着系统回收他的资源
21             //在的话 再赋值
22             if (imageViewReference != null && bitmap != null) {
23                 final ImageView imageView = imageViewReference.get();
24                 if (imageView != null) {
25                     imageView.setImageBitmap(bitmap);
26                 }
27             }
28         }
29     }

 1   //在listview或者gridview的getview方法里 我們就可以直接調用這個方法了
 2     public void loadBitmap(int resId, ImageView imageView) {
 3         //如果取得的task为空 就代表这个iv是新的iv 不是从listview回收站里取的 就可以新建一个task 然后
 4         //用这个task 去新建一个drawable。然后用这个新的imageview去set 这个drawable即可
 5         if (cancelPotentialWork(resId, imageView)) {
 6             final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
 7             final AsyncDrawable asyncDrawable =
 8                     new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
 9             imageView.setImageDrawable(asyncDrawable);
10             task.execute(resId);
11         }
12     }
13
14     //从imageview里取得他的drawable。然后从取得的drawable里取得他的task
15     //这里实际上就可以看出来imageview-drawable-task是1对1的关系了
16     private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
17         if (imageView != null) {
18             final Drawable drawable = imageView.getDrawable();
19             if (drawable instanceof AsyncDrawable) {
20                 final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
21                 return asyncDrawable.getBitmapWorkerTask();
22             }
23         }
24         return null;
25     }
26
27     public static boolean cancelPotentialWork(int data, ImageView imageView) {
28         final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
29         //如果这个task 不为空 就代表这个iv已经有task了 那这种情况
30         if (bitmapWorkerTask != null) {
31             final int bitmapData = bitmapWorkerTask.data;
32             // 如果这个task还没有跑完 那就直接cancel这个task。因为没有跑完就肯定是iv 还没有设定值，所以直接cancel
33             //cancel以后就跳出这个括号 直接返回true了，等同于这个iv是一个新的iv 可以重新绑定新的task
34             if (bitmapData == 0 || bitmapData != data) {
35                 // Cancel previous task
36                 bitmapWorkerTask.cancel(true);
37             } else {
38                 // 如果已经跑完了 那就别绑定了否则会错乱的。所以返回false把 这里返回false loadBitmap就什么都不做的。图形就从根本上
39                 //不会错乱了。
40                 return false;
41             }
42         }
43         // task为空的话就返回true了。
44         return true;
45     }

 1 class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
 2     ...
 3
 4     @Override
 5     protected void onPostExecute(Bitmap bitmap) {
 6         if (isCancelled()) {
 7             bitmap = null;
 8         }
 9
10         if (imageViewReference != null && bitmap != null) {
11             final ImageView imageView = imageViewReference.get();
12             final BitmapWorkerTask bitmapWorkerTask =
13                     getBitmapWorkerTask(imageView);
14             if (this == bitmapWorkerTask && imageView != null) {
15                 imageView.setImageBitmap(bitmap);
16             }
17         }
18     }
19 }

 1 //其实这里代码思路很简单的，就是扩展了一下drawable而已。你每次指定他显示 或者暂时做缓存的时候
 2 //就改动一下计数器，然后check他的状态，在归0的时候 就可以彻底recyle这个资源了
 3 public class RecyclingBitmapDrawable extends BitmapDrawable {
 4
 5     static final String TAG = "CountingBitmapDrawable";
 6
 7     private int mCacheRefCount = 0;
 8     private int mDisplayRefCount = 0;
 9
10     private boolean mHasBeenDisplayed;
11
12     public RecyclingBitmapDrawable(Resources res, Bitmap bitmap) {
13         super(res, bitmap);
14     }
15
16
17     public void setIsDisplayed(boolean isDisplayed) {
18         synchronized (this) {
19             if (isDisplayed) {
20                 mDisplayRefCount++;
21                 mHasBeenDisplayed = true;
22             } else {
23                 mDisplayRefCount--;
24             }
25         }
26
27         checkState();
28     }
29
30
31
32     public void setIsCached(boolean isCached) {
33         synchronized (this) {
34             if (isCached) {
35                 mCacheRefCount++;
36             } else {
37                 mCacheRefCount--;
38             }
39         }
40
41         checkState();
42     }
43
44     private synchronized void checkState() {
45
46         if (mCacheRefCount <= 0 && mDisplayRefCount <= 0 && mHasBeenDisplayed
47                 && hasValidBitmap()) {
48             if (BuildConfig.DEBUG) {
49                 Log.d(TAG, "No longer being used or cached so recycling. "
50                         + toString());
51             }
52
53             getBitmap().recycle();
54         }
55     }
56
57     private synchronized boolean hasValidBitmap() {
58         Bitmap bitmap = getBitmap();
59         return bitmap != null && !bitmap.isRecycled();
60     }
61
62 }

1  final BitmapFactory.Options options = new BitmapFactory.Options();
2         options.inSampleSize = 1;
3         options.inMutable = true;

 1 final BitmapFactory.Options options = new BitmapFactory.Options();
 2         //size必须为1 否则是使用inBitmap属性会报异常
 3         options.inSampleSize = 1;
 4         //这个属性一定要在用在src Bitmap decode的时候 不然你再使用哪个inBitmap属性去decode时候会在c++层面报异常
 5         //BitmapFactory: Unable to reuse an immutable bitmap as an image decoder target.
 6         options.inMutable = true;
 7         inBitmap2 = BitmapFactory.decodeFile(path1,options);
 8         iv.setImageBitmap(inBitmap2);
 9         options.inBitmap = inBitmap2;
10         long start=System.currentTimeMillis();
11         iv2.setImageBitmap(BitmapFactory.decodeFile(path2,options));
12         iv3.setImageBitmap(BitmapFactory.decodeFile(path3,options));
13         iv4.setImageBitmap(BitmapFactory.decodeFile(path4,options));

Android 3.0 (API level 11) introduces the BitmapFactory.Options.inBitmap field. If this option is set, decode methods that take the Options object will attempt to reuse an existing bitmap when loading content. This means that the bitmap's memory is reused, resulting in improved performance, and removing both memory allocation and de-allocation. However, there are certain restrictions with how inBitmap can be used. In particular, before Android 4.4 (API level 19), only equal sized bitmaps are supported. For details, please see the inBitmap documentation.