android图片加载内存优化方法,有效解决大图片内存溢出(oom)

最新推荐文章于 2023-11-07 16:25:24 发布
最新推荐文章于 2023-11-07 16:25:24 发布
阅读量122 收藏
点赞数
文章标签： 移动开发
原文链接：http://www.cnblogs.com/liujhgit/p/4137813.html
版权

　　低内存的手机如果直接加载大图片,往往会出现OOM的情况.即便是主流手机,也不能无限制的加载大图片.所以在显示图片之前,需要对图片处理,把图片缩放为最合适的尺寸再显示.

　　网上很大方法都是不管三七二十一,直接压缩图片.这样可能会导致图片失真,显示模糊.我采用的方式是,显示尺寸有多大,就等比例压缩成多大尺寸的图片,关键关于在于如何寻找最合适的尺寸,下面分享两个关键方法,提取至google开源框架volley

 

    private static int getResizedDimension(int maxPrimary, int maxSecondary,
            int actualPrimary, int actualSecondary) {
        // If no dominant value at all, just return the actual.
        if (maxPrimary == 0 && maxSecondary == 0) {
            return actualPrimary;
        }

        // If primary is unspecified, scale primary to match secondary's scaling
        // ratio.
        if (maxPrimary == 0) {
            double ratio = (double) maxSecondary / (double) actualSecondary;
            return (int) (actualPrimary * ratio);
        }

        if (maxSecondary == 0) {
            return maxPrimary;
        }

        double ratio = (double) actualSecondary / (double) actualPrimary;
        int resized = maxPrimary;
        if (resized * ratio > maxSecondary) {
            resized = (int) (maxSecondary / ratio);
        }
        return resized;
    }

    private static int findBestSampleSize(int actualWidth, int actualHeight,
            int desiredWidth, int desiredHeight) {
        double wr = (double) actualWidth / desiredWidth;
        double hr = (double) actualHeight / desiredHeight;
        double ratio = Math.min(wr, hr);
        float n = 1.0f;
        while ((n * 2) <= ratio) {
            n *= 2;
        }

        return (int) n;
    }

 

 

　　图片源可能来至不同的地方,如Assets,byte[],Bitmap,Uri,Resource,File.针对不同的源采用不同的方法,但是大同小异 
public static Bitmap getImageFromAssetsFile(String fileName, int mMaxWidth,
            int mMaxHeight) {
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
        Bitmap bitmap = null;
        Config preferredConfig = Config.RGB_565;
        AssetManager am = Global.mAppCxt.getResources().getAssets();
        try {
            if (mMaxWidth == 0 && mMaxHeight == 0) {
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = am.open(fileName);
                bitmap = BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
            } else {
                // If we have to resize this image, first get the natural
                // bounds.
                decodeOptions.inJustDecodeBounds = true;
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = am.open(fileName);
                BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
                int actualWidth = decodeOptions.outWidth;
                int actualHeight = decodeOptions.outHeight;

                // Then compute the dimensions we would ideally like to decode
                // to.
                int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                        actualWidth, actualHeight);
                int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                        actualHeight, actualWidth);

                // Decode to the nearest power of two scaling factor.
                decodeOptions.inJustDecodeBounds = false;
                // TODO(ficus): Do we need this or is it okay since API 8
                // doesn't
                // support it?
                // decodeOptions.inPreferQualityOverSpeed =
                // PREFER_QUALITY_OVER_SPEED;
                decodeOptions.inSampleSize = findBestSampleSize(actualWidth,
                        actualHeight, desiredWidth, desiredHeight);
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is2 = am.open(fileName);
                Bitmap tempBitmap = BitmapFactory.decodeStream(is2, null,
                        decodeOptions);
                is2.close();
                // If necessary, scale down to the maximal acceptable size.
                if (tempBitmap != null
                        && (tempBitmap.getWidth() > desiredWidth || tempBitmap
                                .getHeight() > desiredHeight)) {
                    bitmap = Bitmap.createScaledBitmap(tempBitmap,
                            desiredWidth, desiredHeight, true);
                    tempBitmap.recycle();
                } else {
                    bitmap = tempBitmap;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    public static Bitmap getImageFromData(byte[] data, int mMaxWidth,
            int mMaxHeight) {
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
        Bitmap bitmap = null;
        if (mMaxWidth == 0 && mMaxHeight == 0) {
            decodeOptions.inPreferredConfig = Config.RGB_565;
            bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,
                    decodeOptions);
        } else {
            // If we have to resize this image, first get the natural bounds.
            decodeOptions.inJustDecodeBounds = true;
            BitmapFactory.decodeByteArray(data, 0, data.length, decodeOptions);
            int actualWidth = decodeOptions.outWidth;
            int actualHeight = decodeOptions.outHeight;

            // Then compute the dimensions we would ideally like to decode to.
            int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                    actualWidth, actualHeight);
            int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                    actualHeight, actualWidth);

            // Decode to the nearest power of two scaling factor.
            decodeOptions.inJustDecodeBounds = false;
            // TODO(ficus): Do we need this or is it okay since API 8 doesn't
            // support it?
            // decodeOptions.inPreferQualityOverSpeed =
            // PREFER_QUALITY_OVER_SPEED;
            decodeOptions.inSampleSize = findBestSampleSize(actualWidth,
                    actualHeight, desiredWidth, desiredHeight);
            Bitmap tempBitmap = BitmapFactory.decodeByteArray(data, 0,
                    data.length, decodeOptions);

            // If necessary, scale down to the maximal acceptable size.
            if (tempBitmap != null
                    && (tempBitmap.getWidth() > desiredWidth || tempBitmap
                            .getHeight() > desiredHeight)) {
                bitmap = Bitmap.createScaledBitmap(tempBitmap, desiredWidth,
                        desiredHeight, true);
                tempBitmap.recycle();
            } else {
                bitmap = tempBitmap;
            }
        }
        return bitmap;
    }

    public static Bitmap getImageFromBitmap(Bitmap srcBitmap, int mMaxWidth,
            int mMaxHeight) {
        Bitmap bitmap = null;
        if (mMaxWidth == 0 && mMaxHeight == 0) {
            bitmap = srcBitmap;
        } else {
            int actualWidth = srcBitmap.getWidth();
            int actualHeight = srcBitmap.getHeight();

            // Then compute the dimensions we would ideally like to decode to.
            int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                    actualWidth, actualHeight);
            int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                    actualHeight, actualWidth);
            bitmap = Bitmap.createScaledBitmap(srcBitmap, desiredWidth,
                    desiredHeight, true);
        }
        return bitmap;
    }

    public static Bitmap getImageFromUri(Uri uri, int mMaxWidth,
            int mMaxHeight) {
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
        Bitmap bitmap = null;
        Config preferredConfig = Config.RGB_565;
        try {
            if (mMaxWidth == 0 && mMaxHeight == 0) {
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = Global.mAppCxt.getContentResolver()
                        .openInputStream(uri);
                bitmap = BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
            } else {
                // If we have to resize this image, first get the natural
                // bounds.
                decodeOptions.inJustDecodeBounds = true;
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = Global.mAppCxt.getContentResolver()
                        .openInputStream(uri);
                BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
                int actualWidth = decodeOptions.outWidth;
                int actualHeight = decodeOptions.outHeight;

                // Then compute the dimensions we would ideally like to decode
                // to.
                int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                        actualWidth, actualHeight);
                int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                        actualHeight, actualWidth);

                // Decode to the nearest power of two scaling factor.
                decodeOptions.inJustDecodeBounds = false;
                // TODO(ficus): Do we need this or is it okay since API 8
                // doesn't
                // support it?
                // decodeOptions.inPreferQualityOverSpeed =
                // PREFER_QUALITY_OVER_SPEED;
                decodeOptions.inSampleSize = findBestSampleSize(actualWidth,
                        actualHeight, desiredWidth, desiredHeight);
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is2 = Global.mAppCxt.getContentResolver()
                        .openInputStream(uri);
                Bitmap tempBitmap = BitmapFactory.decodeStream(is2, null,
                        decodeOptions);
                is2.close();
                // If necessary, scale down to the maximal acceptable size.
                if (tempBitmap != null
                        && (tempBitmap.getWidth() > desiredWidth || tempBitmap
                                .getHeight() > desiredHeight)) {
                    bitmap = Bitmap.createScaledBitmap(tempBitmap,
                            desiredWidth, desiredHeight, true);
                    tempBitmap.recycle();
                } else {
                    bitmap = tempBitmap;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    public static Bitmap getImageFromResource(int resId, int mMaxWidth,
            int mMaxHeight) {
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
        Bitmap bitmap = null;
        Config preferredConfig = Config.RGB_565;
        try {
            if (mMaxWidth == 0 && mMaxHeight == 0) {
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = Global.mAppCxt.getResources().openRawResource(
                        resId);
                bitmap = BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
            } else {
                // If we have to resize this image, first get the natural
                // bounds.
                decodeOptions.inJustDecodeBounds = true;
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is = Global.mAppCxt.getResources().openRawResource(
                        resId);
                BitmapFactory.decodeStream(is, null, decodeOptions);
                is.close();
                int actualWidth = decodeOptions.outWidth;
                int actualHeight = decodeOptions.outHeight;

                // Then compute the dimensions we would ideally like to decode
                // to.
                int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                        actualWidth, actualHeight);
                int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                        actualHeight, actualWidth);

                // Decode to the nearest power of two scaling factor.
                decodeOptions.inJustDecodeBounds = false;
                // TODO(ficus): Do we need this or is it okay since API 8
                // doesn't
                // support it?
                // decodeOptions.inPreferQualityOverSpeed =
                // PREFER_QUALITY_OVER_SPEED;
                decodeOptions.inSampleSize = findBestSampleSize(actualWidth,
                        actualHeight, desiredWidth, desiredHeight);
                decodeOptions.inPreferredConfig = preferredConfig;
                InputStream is2 = Global.mAppCxt.getResources()
                        .openRawResource(resId);
                Bitmap tempBitmap = BitmapFactory.decodeStream(is2, null,
                        decodeOptions);
                is2.close();
                // If necessary, scale down to the maximal acceptable size.
                if (tempBitmap != null
                        && (tempBitmap.getWidth() > desiredWidth || tempBitmap
                                .getHeight() > desiredHeight)) {
                    bitmap = Bitmap.createScaledBitmap(tempBitmap,
                            desiredWidth, desiredHeight, true);
                    tempBitmap.recycle();
                } else {
                    bitmap = tempBitmap;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    public static Bitmap getImageFromFile(File file, int mMaxWidth,
            int mMaxHeight) {
        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
        Bitmap bitmap = null;
        Config preferredConfig = Config.RGB_565;
        try {
            if (mMaxWidth == 0 && mMaxHeight == 0) {
                bitmap = BitmapFactory.decodeFile(file.getPath());
            } else {
                // If we have to resize this image, first get the natural
                // bounds.
                decodeOptions.inJustDecodeBounds = true;
                decodeOptions.inPreferredConfig = preferredConfig;
                bitmap = BitmapFactory
                        .decodeFile(file.getPath(), decodeOptions);
                int actualWidth = decodeOptions.outWidth;
                int actualHeight = decodeOptions.outHeight;

                // Then compute the dimensions we would ideally like to decode
                // to.
                int desiredWidth = getResizedDimension(mMaxWidth, mMaxHeight,
                        actualWidth, actualHeight);
                int desiredHeight = getResizedDimension(mMaxHeight, mMaxWidth,
                        actualHeight, actualWidth);

                // Decode to the nearest power of two scaling factor.
                decodeOptions.inJustDecodeBounds = false;
                // TODO(ficus): Do we need this or is it okay since API 8
                // doesn't
                // support it?
                // decodeOptions.inPreferQualityOverSpeed =
                // PREFER_QUALITY_OVER_SPEED;
                decodeOptions.inSampleSize = findBestSampleSize(actualWidth,
                        actualHeight, desiredWidth, desiredHeight);
                decodeOptions.inPreferredConfig = preferredConfig;
                Bitmap tempBitmap = BitmapFactory.decodeFile(file.getPath(),
                        decodeOptions);
                // If necessary, scale down to the maximal acceptable size.
                if (tempBitmap != null
                        && (tempBitmap.getWidth() > desiredWidth || tempBitmap
                                .getHeight() > desiredHeight)) {
                    bitmap = Bitmap.createScaledBitmap(tempBitmap,
                            desiredWidth, desiredHeight, true);
                    tempBitmap.recycle();
                } else {
                    bitmap = tempBitmap;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
View Code

　　关键代码decodeOptions.inJustDecodeBounds = true;指得是只绘制边界,不直接加载图片,通过边界尺寸再结合之前的两个方法计算最合适的尺寸后才加载图片
　　Config preferredConfig = Config.RGB_565;不支持透明度,如果需要透明度,就替换成ARGB_8888,但是内存占用会增加一倍.具体可以参考源码的解释
　　RGB_565,Each pixel is stored on 2 bytes
　　ARGB_8888,Each pixel is stored on 4 bytes

转载于:https://www.cnblogs.com/liujhgit/p/4137813.html

weixin_30247781
关注
Recyclerview使用Glide加载大量图片时出现内存溢出（OOM）
weixin_41633457的博客
07-30 2664
前言 最近在项目中使用了一个GitHub上开源的图片选择器库，在android8.0以上的机子测试没发现异常，正常将相册里的相片加载到Recyclerview，但测试了美图一台Android7.1的手机却出现了闪退，看日志发现是OutOfMemory。首先想到的是Glide的使用是不是不太正确，于是有了以下尝试： 尝试1：Glide的diskCacheStrategy属性 Glide.with(mContext).load(image.getPath()) .skip
【Android】使用glide加载未知尺寸图片导致OOM问题的解决方案
不想做菜鸟的小螃蟹
12-20 5874
问题：app中有一个Activity用于查看大图，最近出现了一些超大图（内存占用超100M），导致app出现OOM导致的crash 背景：大图的来源中只给出了图片的url，除此之外再无任何信息。图片url提供方对于提供图片其他信息（如宽/高），成本较高，讨论之后有客户端自己进行处理。   1⃣️OOM产生的原因 内存占用量超过了vm能分配的最大内存量，或者一下子申请了一块非常大的内存（比如...
android加载大量图片内存溢出的三种解决办法
08-06
android加载大量图片内存溢出的三种解决办法
从内存优化视角再看 Glide 图片加载库
最新发布
maniuT的博客
11-07 477
Glide 作为常用的图片加载框架，框架层面已经对内存方面有不少优化，但作为一个图片框架，确保正确性一定是第一位的，因此在应用层还可以在适当的场景做一些额外的优化，当然你需要了解优化设置可能产生的问题。由于图片设置了 centerCrop 属性，在直观看图片会按等比居中缩放，但由于 decode 发生在 scaleType 生效之前，因此使用 Glide 加载图片时会以 ImageView 的实际尺寸（即全屏） 的宽高来解码图片，由此产生了不必要的内存开销。为了帮助到大家更好的掌握好 开源框架相关知识点，
Android的加载大图片引起内存问题之OOM异常
ChatHello的博客
08-17 605
大图片所引起的内存问题（oom）： 在我们android开发中，一个应用使用的内存大小是有限制的.在应用中,如果大量的使用bitmap就很可能导致内存溢出的问题。比如我在曾经的一个项目中遇到的问题：要使用Gallery来显示多张不同的图片，在给Gallery的每个Item设置图片的时候，想到Bitmap如果不手动的recycle，系统是不会回收它所在的资源的，因为android为了提高效率，bi
加载大图片时，出现的OOM异常，以及处理OOM异常的方法
为了追求卓越，敢于犯错，敢于失败。
11-11 1021
首先 , 得明白什么是 OOM异常, 即OutOfMemory异常,内存溢出导致的. 1,  如何计算出 加载图片进内存时的大小?  在 Android中 , 加载一张图片时,比如 一张 2560X1920的高清图片,
Glide内存处理优化
Bue_Sky的博客
11-09 8222
一、前言 Glide 是 Google 官方推荐的一款图片加载库，使用起来也非常的简单便利，Glide 它帮我们完成了很多很重要，但是却通用的功能，例如：图片的加载压缩、展示、加载图片的内存管理等等。 对 Glide 还不熟悉的朋友，可以参考 《一篇好文，助你上手 Glide》 但是，在使用 Glide 的时候，有一些小技巧，可以让你的内存更优化，避免可能出现的 OOM。例如
Android加载图片内存溢出问题解决方法
09-03
在Android应用开发中，图片加载是常见的操作，但如果不恰当处理，可能会导致内存溢出（Out Of Memory，简称OOM）问题。尤其当处理大尺寸图片时，由于Bitmap对象会占用大量内存，很容易超出Android设备的内存限制。...
android 解决ViewPager加载大量图片内存溢出问题
09-02
在Android开发中，ViewPager是一个非常常用的组件...通过以上方法，可以有效地解决ViewPager加载大量图片导致的内存溢出问题，同时提高应用的性能和用户体验。在实际开发中，应结合项目的具体需求选择适合的优化策略。
android解决加载图片内存溢出
10-30
本篇文章将深入探讨如何在Android中有效解决图片加载导致的内存溢出问题。 首先，我们需要理解为什么图片加载会引发内存溢出。Android系统为每个应用分配了一定的内存限制，当加载大尺寸图片时，如果直接将其原样...
解决Glide批量加载图片时出现OOM内存溢出的问题
IT界寿险规划师的博客
04-25 5826
在接手的项目中原来是这样使用的。如下 public static void setImage(ImageView imageview, String url, Context context, int defultPic) { if (TextUtils.isEmpty(url + "")) { imageview.setImageResource(de...
在Recyclerview使用GlideAPP加载大量图片导致内存溢出（oom）
weixin_30663391的博客
07-27 671
网络上有很多解决的办法，但是都是在清理磁盘缓存和内存上做，并不能及时释放内存。 1.可以在每次请求数据和加载数据后调用 /** * 清除内存缓存. */public static void clearMemoryCache(Context context){ // This method must be called on the main thread. System.gc();...
Glide加载图片into(Target)导致OOM异常
陈一苇的博客
03-31 9891
最近在项目中遇到Drawable转换成Bitmap的需求，Glide加载的Drawable对象，而需要的是Bitmap对象。于是找到一个可以使用的方法，但是程序运行之后出现OOM异常，通过AndroidStudio自带的内存检测工具观察得到在加载图片的时候，memory的使用大约增长了几十M。经过对该方法的检查，drawable.getIntrinsicWidth()加载的是原图片的长宽。而Glid
Android内存优化之图片优化
计蒙不吃鱼的博客
04-08 1万+
关于图片优化，大概如下 为什么要进行图片优化 相信大概刚开始学习Android的时候有过图片过大而直接报错的情况，下面简单介绍一下OOM问题,Android支持的图片格式及图片优化的几种方式 什么是OOM？：Android系统的进程（APP级别）有最大的内存限制，超过这个限制系统就会抛出）OOM错误 图片OOM问题产生的几种情况 1.一个页面一次加载过多的图片 2.加载大图片没有进行压缩 3....
图片加载之Glide使用
热门推荐
一花一世界的博客
03-31 2万+
Glide的基本用法
bitmap的处理，尽量避免OOM
自由人
08-19 3026
bitmap压缩处理，远离OOM
Glide加载网络图片，服务器内容更新但是Glide缓存无法清理的解决办法
程序猿成长之路
04-28 7521
先描述下现象，load的URL没有改变，但是服务器上图片的内容改变了，Glide清理了缓存但是图片没有更新。 解决办法就是给图片加上signature的标识 Glide.with(context.getApplicationContext()) .load(imageurl) .signature(new Stri
Android图片OOM内存溢出：原因与解决方案
处理图片OOM问题的关键在于优化内存管理。常见的做法包括： 1. **图片预加载和压缩**：按需加载图片，避免一次性加载过多图片占用大量内存。使用合适的图片压缩算法减少图片大小。 2. **Bitmap内存优化**：使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值