我有iOS经验，我很沮丧地发现加载和显示图像这样基本的问题。毕竟，每个人都有这个问题，试图显示合理大小的图像。不管怎样，这里有两个改变解决了我的问题(并使我的应用程序非常灵敏)。

1)每次执行BitmapFactory. decodexyz()时，确保传入一个BitmapFactory。选项inPurgeable设置为true(最好inInputShareable也设置为true)。

2)绝对不要使用位图。createBitmap(width, height, Config.ARGB_8888)。我的意思是绝不!我从来没有过这个东西在几次传递后不产生内存错误。没有多少recycle()， System.gc()，任何有用的东西。它总是抛出异常。另一种实际工作的方法是在你的绘图中有一个虚拟图像(或另一个你使用上述步骤1解码的位图)，将其重新缩放为你想要的任何东西，然后操纵结果位图(例如将它传递到画布上以获得更多乐趣)。所以，你应该使用的是:位图。createScaledBitmap(srcBitmap, width, height, false)。如果出于某种原因你必须使用暴力创建方法，那么至少要传递Config.ARGB_4444。

这几乎可以保证节省你几个小时，如果不是几天。所有关于缩放图像等的讨论都是行不通的(除非你认为得到错误的大小或降级的图像是一个解决方案)。

我做了以下操作来获取图像并动态地调整它的大小。希望这能有所帮助

Bitmap bm;
bm = Bitmap.createScaledBitmap(BitmapFactory.decodeFile(filepath), 100, 100, true);
mPicture = new ImageView(context);
mPicture.setImageBitmap(bm);    

最近我看到了很多关于OOM异常和缓存的问题。开发人员指南中有一篇关于这方面的非常好的文章，但有些人往往无法以合适的方式实现它。

因此，我编写了一个示例应用程序，演示了Android环境中的缓存。这个实现还没有得到一个OOM。

在答案的末尾可以找到源代码的链接。

要求:

Android API 2.1或更高版本(我根本无法在API 1.6中为应用程序获得可用内存-这是API 1.6中唯一不能工作的代码段) Android支持包

特点:

如果方向改变，使用单例保存缓存 将分配的应用程序内存的八分之一用于缓存(如果需要可以修改) 大的位图缩放(您可以定义您想要允许的最大像素) 控制在下载位图之前是否有可用的互联网连接 确保每行只实例化一个任务 如果你扔掉ListView，它就不会下载中间的位图

这不包括:

磁盘缓存。这应该很容易实现-只要指向一个不同的任务，从磁盘获取位图

示例代码:

正在下载的图像是来自Flickr的图像(75x75)。然而，不管你想处理什么图像url，如果它超过最大值，应用程序就会缩小它。在这个应用程序中，url只是一个字符串数组。

LruCache有一个处理位图的好方法。但是，在这个应用程序中，我将一个LruCache实例放在我创建的另一个缓存类中，以便使应用程序更加可行。

Cache.java的关键内容(loadBitmap()方法是最重要的):

public Cache(int size, int maxWidth, int maxHeight) {
    // Into the constructor you add the maximum pixels
    // that you want to allow in order to not scale images.
    mMaxWidth = maxWidth;
    mMaxHeight = maxHeight;

    mBitmapCache = new LruCache<String, Bitmap>(size) {
        protected int sizeOf(String key, Bitmap b) {
            // Assuming that one pixel contains four bytes.
            return b.getHeight() * b.getWidth() * 4;
        }
    };

    mCurrentTasks = new ArrayList<String>();    
}

/**
 * Gets a bitmap from cache. 
 * If it is not in cache, this method will:
 * 
 * 1: check if the bitmap url is currently being processed in the
 * BitmapLoaderTask and cancel if it is already in a task (a control to see
 * if it's inside the currentTasks list).
 * 
 * 2: check if an internet connection is available and continue if so.
 * 
 * 3: download the bitmap, scale the bitmap if necessary and put it into
 * the memory cache.
 * 
 * 4: Remove the bitmap url from the currentTasks list.
 * 
 * 5: Notify the ListAdapter.
 * 
 * @param mainActivity - Reference to activity object, in order to
 * call notifyDataSetChanged() on the ListAdapter.
 * @param imageKey - The bitmap url (will be the key).
 * @param imageView - The ImageView that should get an
 * available bitmap or a placeholder image.
 * @param isScrolling - If set to true, we skip executing more tasks since
 * the user probably has flinged away the view.
 */
public void loadBitmap(MainActivity mainActivity, 
        String imageKey, ImageView imageView,
        boolean isScrolling) {
    final Bitmap bitmap = getBitmapFromCache(imageKey); 

    if (bitmap != null) {
        imageView.setImageBitmap(bitmap);
    } else {
        imageView.setImageResource(R.drawable.ic_launcher);
        if (!isScrolling && !mCurrentTasks.contains(imageKey) && 
                mainActivity.internetIsAvailable()) {
            BitmapLoaderTask task = new BitmapLoaderTask(imageKey,
                    mainActivity.getAdapter());
            task.execute();
        }
    } 
}

您不需要在Cache.java文件中编辑任何内容，除非您想实现磁盘缓存。

java的关键部分:

public void onScrollStateChanged(AbsListView view, int scrollState) {
    if (view.getId() == android.R.id.list) {
        // Set scrolling to true only if the user has flinged the       
        // ListView away, hence we skip downloading a series
        // of unnecessary bitmaps that the user probably
        // just want to skip anyways. If we scroll slowly it
        // will still download bitmaps - that means
        // that the application won't wait for the user
        // to lift its finger off the screen in order to
        // download.
        if (scrollState == SCROLL_STATE_FLING) {
            mIsScrolling = true;
        } else {
            mIsScrolling = false;
            mListAdapter.notifyDataSetChanged();
        }
    } 
}

// Inside ListAdapter...
@Override
public View getView(final int position, View convertView, ViewGroup parent) {           
    View row = convertView;
    final ViewHolder holder;

    if (row == null) {
        LayoutInflater inflater = getLayoutInflater();
        row = inflater.inflate(R.layout.main_listview_row, parent, false);  
        holder = new ViewHolder(row);
        row.setTag(holder);
    } else {
        holder = (ViewHolder) row.getTag();
    }   

    final Row rowObject = getItem(position);

    // Look at the loadBitmap() method description...
    holder.mTextView.setText(rowObject.mText);      
    mCache.loadBitmap(MainActivity.this,
            rowObject.mBitmapUrl, holder.mImageView,
            mIsScrolling);  

    return row;
}

getView()经常被调用。如果我们没有实现检查，以确保我们不会在每行启动无限数量的线程，那么在那里下载图像通常不是一个好主意。Cache.java检查rowObject。mBitmapUrl已经在一个任务，如果它是，它不会开始另一个任务。因此，我们很可能不会超过AsyncTask池的工作队列限制。

下载:

您可以从https://www.dropbox.com/s/pvr9zyl811tfeem/ListViewImageCache.zip下载源代码。

最后一句话:

我已经测试了这个几个星期了，我还没有得到一个OOM异常。我已经在模拟器、我的Nexus One和Nexus s上测试了这个功能。我测试了包含高清图像的图像url。唯一的瓶颈是下载需要更多的时间。

只有一种可能的情况下，我可以想象OOM将会出现，那就是如果我们下载许多非常大的图像，在它们被缩放并放入缓存之前，将同时占用更多的内存并导致OOM。但无论如何，这都不是一个理想的情况，而且很可能不可能以更可行的方式解决。

在评论中报告错误!: -)

这段代码将有助于从可绘制的图中加载大的位图

public class BitmapUtilsTask extends AsyncTask<Object, Void, Bitmap> {

    Context context;

    public BitmapUtilsTask(Context context) {
        this.context = context;
    }

    /**
     * Loads a bitmap from the specified url.
     * 
     * @param url The location of the bitmap asset
     * @return The bitmap, or null if it could not be loaded
     * @throws IOException
     * @throws MalformedURLException
     */
    public Bitmap getBitmap() throws MalformedURLException, IOException {       

        // Get the source image's dimensions
        int desiredWidth = 1000;
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;

        BitmapFactory.decodeResource(context.getResources(), R.drawable.green_background , options);

        int srcWidth = options.outWidth;
        int srcHeight = options.outHeight;

        // Only scale if the source is big enough. This code is just trying
        // to fit a image into a certain width.
        if (desiredWidth > srcWidth)
            desiredWidth = srcWidth;

        // Calculate the correct inSampleSize/scale value. This helps reduce
        // memory use. It should be a power of 2
        int inSampleSize = 1;
        while (srcWidth / 2 > desiredWidth) {
            srcWidth /= 2;
            srcHeight /= 2;
            inSampleSize *= 2;
        }
        // Decode with inSampleSize
        options.inJustDecodeBounds = false;
        options.inDither = false;
        options.inSampleSize = inSampleSize;
        options.inScaled = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        options.inPurgeable = true;
        Bitmap sampledSrcBitmap;

        sampledSrcBitmap =  BitmapFactory.decodeResource(context.getResources(), R.drawable.green_background , options);

        return sampledSrcBitmap;
    }

    /**
     * The system calls this to perform work in a worker thread and delivers
     * it the parameters given to AsyncTask.execute()
     */
    @Override
    protected Bitmap doInBackground(Object... item) {
        try { 
          return getBitmap();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

要修复OutOfMemory错误，你应该这样做:

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 8;
Bitmap preview_bitmap = BitmapFactory.decodeStream(is, null, options);

这个inSampleSize选项可以减少内存消耗。

这是一个完整的方法。首先，它读取图像大小而不解码内容本身。然后它找到最佳的inSampleSize值，它应该是2的幂，最后图像被解码。

// Decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f) {
    try {
        // Decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(new FileInputStream(f), null, o);

        // The new size we want to scale to
        final int REQUIRED_SIZE=70;

        // Find the correct scale value. It should be the power of 2.
        int scale = 1;
        while(o.outWidth / scale / 2 >= REQUIRED_SIZE && 
              o.outHeight / scale / 2 >= REQUIRED_SIZE) {
            scale *= 2;
        }

        // Decode with inSampleSize
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize = scale;
        return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
    } catch (FileNotFoundException e) {}
    return null;
}

看起来你用的图片尺寸很大。所以一些旧的设备崩溃是因为堆内存满了。在旧设备(蜂窝或ICS或任何低端型号设备)尝试使用android:largeHeap="true"在清单文件下的应用程序标签或通过使用下面的代码减少位图的大小。

Bitmap bMap;
BitmapFactory.Options options = new BitmapFactory.Options(); 
options.InSampleSize = 8;
bMap= BitmapFactory.DecodeFile(imgFile.AbsolutePath, options);

你也可以给4或12或16来减少位图的大小