图片处理(防止内存溢出)

最新推荐文章于 2023-05-29 10:39:00 发布
最新推荐文章于 2023-05-29 10:39:00 发布
阅读量4.2k 收藏 5
点赞数
分类专栏： 安卓学习笔记 文章标签： 内存溢出 内存泄露
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012792686/article/details/69666508
版权

导读

本篇承接 内存泄漏与内存溢出总结

图片处理(防止内存溢出)

三要素(缩放比例、解码格式、局部加载)

配合软引用BitmapCache类,或Lru算法 BitmapLruCache 优化效果更好

除此以外,还可以使用第三方图片压缩工具
TinyPNG

package zs.xmx.todo;
/*
 * @创建者     默小铭
 * @博客       http://blog.csdn.net/u012792686
 * @创建时间   2017/4/7
 * @本类描述      图片处理(防止内存溢出)
 * @内容说明 
 *            三要素:
 *            缩放比例、解码格式、局部加载
 *            配合软引用BitmapCache类,或Lru算法 BitmapLruCache 优化效果更好
 * @补充内容
 * //todo 这里总结归类到BitmapUtils
 */

public class BitmapHandleDemo extends Activity {
    private ImageView mImageView;
    private Bitmap mBitmap = null;
    private File   mFile   = null;
    private int SCREEN_WIDTH, SCREEN_HEIGHT;
    private int shiftpx = 0; //偏移量
    private Button mBtn_choosepic;
    private Button mBtn_change_option;
    private Button mBtn_change_rgb;
    private Button mBtn_partload;
    private Button mBtn_offset;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bitmap_handle);
        initView();
        initEvent();

    }

    private void initEvent() {
        DisplayMetrics dm = new DisplayMetrics();
        dm = getApplicationContext().getResources().getDisplayMetrics();
        //这里其实要转dp
        SCREEN_WIDTH = dm.widthPixels;
        SCREEN_HEIGHT = dm.heightPixels;
    }

    private void initView() {
        mImageView = (ImageView) findViewById(iv);
        mBtn_choosepic = (Button) findViewById(R.id.choosepic);
        mBtn_change_option = (Button) findViewById(R.id.change_option);
        mBtn_change_rgb = (Button) findViewById(R.id.change_rgb);
        mBtn_partload = (Button) findViewById(partload);
        mBtn_offset = (Button) findViewById(R.id.offset);
    }

    /**
     * URI方式打开相册获取图片
     */
    private void getPic() {
        Intent intent = new Intent(Intent.ACTION_PICK, null);
        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
        startActivityForResult(intent, 1);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {

        try {
            String path = getRealPathFromURL(data.getData());
            mFile = new File(path);
            if (mFile == null)
                return;
            if (mFile.length() == 0) {
                mFile.delete();
                return;
            }
            Log.i("xmx", "file:" + mFile.getName() + ",原图大小length:" + mFile.length());
            FileInputStream fis = new FileInputStream(mFile);
            mBitmap = BitmapFactory.decodeStream(fis);
            Log.i("xmx", "bitmap,Bitmap解析图片后大小length:" + mBitmap.getByteCount());
            mImageView.setImageBitmap(mBitmap);
        } catch (Exception e) {
            e.printStackTrace();
            Log.i("xmx", "bitmap,load error:" + e.getMessage());
        }
    }

    /**
     * 根据URI获得File文件路径
     *
     * @param contentUri
     * @return
     */
    private String getRealPathFromURL(Uri contentUri) {
        String res = null;
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = getApplicationContext().getContentResolver().query(contentUri, proj, null, null, null);
        if (cursor.moveToFirst()) {
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            res = cursor.getString(column_index);
        }
        cursor.close();
        return res;
    }

    /**
     * 点击原图按钮
     *
     * @param view
     */
    public void choosepic(View view) {
        getPic();
    }

    /**
     * 点击缩放比例按钮
     *
     * @param view
     */
    public void change_option(View view) {
        if (mFile == null) {
            return;
        }
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true; //只获取边界不加载
            BitmapFactory.decodeStream(new FileInputStream(mFile), null, options);
            int width_tmp = options.outWidth, height_tmp = options.outHeight;
            int scale = 2;
            while (true) {
                if (width_tmp / scale < SCREEN_WIDTH)
                    break;
                scale += 2;
            }
            scale /= 2;
            BitmapFactory.Options options2 = new BitmapFactory.Options();
            options2.inSampleSize = scale; //上述操作得到抽样比之后,在赋给inSampleSize
            Log.i("xmx", "bitmap,缩放比例scale:" + scale);
            FileInputStream fis = new FileInputStream(mFile);
            mBitmap = BitmapFactory.decodeStream(fis, null, options2);
            Log.i("xmx", "scale-bitmap,缩放比例后的图片大小legth:" + mBitmap.getByteCount());
            mImageView.setImageBitmap(mBitmap);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 点击更改解码格式按钮
     *
     * @param view
     */
    public void change_rgb(View view) {
        if (mFile == null) {
            return;
        }
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inPreferredConfig = Bitmap.Config.RGB_565;
            FileInputStream fis = new FileInputStream(mFile);
            mBitmap = BitmapFactory.decodeStream(fis, null, options);
            Log.i("xmx", "RGB_565-bitmap,更换解码格式后的图片大小legth:" + mBitmap.getByteCount());
            mImageView.setImageBitmap(mBitmap);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 点击局部加载按钮
     *
     * @param view
     */
    public void partload(View view) {
        partload_offset();
    }

    private void partload_offset() {
        if (mFile == null) {
            return;
        }
        try {
            FileInputStream fis = new FileInputStream(mFile);
            //获取图片的宽高
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true; //只获取边界不加载
            BitmapFactory.decodeStream(new FileInputStream(mFile), null, options);
            int width = options.outWidth, height = options.outHeight;

            //设置显示图片的中心区域
            BitmapRegionDecoder bitmapRegionDecoder = BitmapRegionDecoder.newInstance(fis, false);//部分图片解析API
            BitmapFactory.Options options2 = new BitmapFactory.Options();
            mBitmap = bitmapRegionDecoder.decodeRegion(new Rect(width / 2 - SCREEN_WIDTH / 2 + shiftpx, height / 2 - SCREEN_HEIGHT / 2,
                    width / 2 + SCREEN_WIDTH / 2 + shiftpx, height / 2 + SCREEN_HEIGHT / 2), options2);
            mImageView.setImageBitmap(mBitmap);
            Log.i("xmx", "PartLoad-bitmap,局部加载图片的大小legth:" + mBitmap.getByteCount());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void offset(View view) {
        shiftpx += 10;
        partload_offset();
    }


}

BitmapCache 软应用管理多张图片


package zs.xmx.todo;
/*
 * @创建者     默小铭
 * @博客       http://blog.csdn.net/u012792686
 * @创建时间   2017/4/8
 * @本类描述      软引用方式管理多张图片
 * @内容说明   //TODO 归类到BitmapUtils
 * @补充内容
 *
 * ---------------------------------     
 * @更新时间   
 * @新增内容   
 *
 */

import android.graphics.Bitmap;
import android.os.Build;
import android.util.ArrayMap;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

public class BitmapCache {
    static private BitmapCache cache;

    private ArrayMap<String, MySoftRef> hashRefs;
    //垃圾引用的队列(所引用的对象已经被回收,则将该引用存入队列)
    private ReferenceQueue<Bitmap>      mBitmapReferenceQueue;

    /**
     * 继承SoftReference,是的每一个实例都具有可识别的标识
     */
    private class MySoftRef extends SoftReference<Bitmap> {
        private String _key = "";

        public MySoftRef(Bitmap referent, ReferenceQueue<Bitmap> q, String key) {
            super(referent, q);
            _key = key;
        }
    }

    private BitmapCache() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            hashRefs = new ArrayMap<String, MySoftRef>();
        }
        mBitmapReferenceQueue = new ReferenceQueue<Bitmap>();
    }

    public static BitmapCache getInstance() {
        if (cache == null) {
            cache = new BitmapCache();
        }
        return cache;
    }

    /**
     * 以软引用的方式对一个Bitmap对象的实例进行引用并保存该引用
     */
    public void addCacheBitmap(Bitmap bmp, String key) {
        cleanCache();//清除垃圾引用
        MySoftRef ref = new MySoftRef(bmp, mBitmapReferenceQueue, key);
        hashRefs.put(key, ref);
    }

    /**
     * 依据所指定的drawable下的图片资源ID号,
     * (可以按需求从网络或本地获取),
     * 重新获取相应Bitmap对象的实例
     */
    //public Bitmap getBitmap(int resId, Context context)
    public Bitmap getBitmap(int resId) {
        Bitmap bmp = null;
        //缓存中是否有该Bitmap实例的引用,如果用,从软引用中取
        try {
            if (hashRefs.containsKey(resId)) {
                MySoftRef ref = (MySoftRef) hashRefs.get(resId);
                bmp = (Bitmap) ref.get();
            }
            return bmp;
        } catch (NullPointerException e) {
            return null;
        }
    }

    private void cleanCache() {
        MySoftRef ref = null;
        while ((ref = (MySoftRef) mBitmapReferenceQueue.poll()) != null) {
            hashRefs.remove(ref._key);
        }
    }

    /**
     * 清除Cache内的全部内容
     */
    public void clearCach() {
        cleanCache();
        hashRefs.clear();
        System.gc();
        System.runFinalization();
    }
}

BitmapLruCache Lru算法管理多张图片


package zs.xmx.todo;
/*
 * @创建者     默小铭
 * @博客       http://blog.csdn.net/u012792686
 * @创建时间   2017/4/8
 * @本类描述      Lru算法管理多张图片
 * @内容说明   //TODO 归类到BitmapUtils
 * @补充内容
 *
 * ---------------------------------     
 * @更新时间   
 * @新增内容   
 *
 */

import android.graphics.Bitmap;
import android.util.Log;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class BitmapLruCache {
    private static final String              TAG   = "xmx";
    //容量8bit,填充比0.75,true表示使用LRU算法
    //LinkedHashMap线程不安全,因此要在外部加个同步
    private              Map<String, Bitmap> cache = Collections.synchronizedMap(
            new LinkedHashMap<String, Bitmap>(8, 0.75f, true));
    private              long                size  = 0; //存 当前内存大小
    private              long                limit = 1000000; //限制最后内存 bytes

    public BitmapLruCache() {
        //使用App允许的 25% 可用内存大小
        setLimit(Runtime.getRuntime().maxMemory() / 4);
    }

    private void setLimit(long new_limit) {
        limit = new_limit;
        Log.i(TAG, "MemoryCache will use up to" + limit / 1024. / 1024. + "MB");
    }

    /**
     * 获取图片
     */
    public Bitmap get(String id) {
        try {
            if (!cache.containsKey(id))
                return null;
            return cache.get(id);
        } catch (NullPointerException e) {
            return null;
        }
    }

    public void put(String id, Bitmap bitmap) {
        try {
            if (cache.containsKey(id))
                size -= getSizeInBytes(cache.get(id));//- 就是将原来的图片删掉
            cache.put(id, bitmap);
            size += getSizeInBytes(bitmap);//+ 将新的图片输入
            checkSize();
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    private long getSizeInBytes(Bitmap bitmap) {
        if (bitmap == null)
            return 0;
        //行子节*高度(低版本)
        //高版本 bitmap.getByteCount();
        return bitmap.getRowBytes() * bitmap.getHeight();
    }

    /**
     * 拿到使用最少的图片对象,然后remove掉
     */
    private void checkSize() {
        Log.i(TAG, "Cache size=" + size + "length=" + cache.size());
        if (size > limit) {
            Iterator<Map.Entry<String, Bitmap>> iterator = cache.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Bitmap> entry = iterator.next();
                size -= getSizeInBytes(entry.getValue());
                iterator.remove();
                if (size <= limit)
                    break;
            }
            Log.i(TAG, "Clean size,New size" + cache.size());
        }
    }

    public void clear() {
        cache.clear();

    }

}

总结:

  • 如果觉得文章对您有用,点击一个关注憋
默尛铭
关注
专栏目录
java 在计算机内存中创建一个图像
06-21
java 在计算机内存中创建一个图像 java 在计算机内存中创建一个图像 java 在计算机内存中创建一个图像
Android 异步获取网络图片并处理导致内存溢出问题解决方法
09-05
为了防止内存溢出，我们使用`BitmapFactory.Options`来控制图片的解码过程。通常，我们可以设置`inSampleSize`属性来减小图片的解码大小。此外，我们还需要确保在不再需要Bitmap时将其回收，以释放内存。 ```java ...
android自定义相册 支持低端机不内存溢出
weixin_30699741的博客
06-21 64
1 之前在网上看的自定义相册很多时候在低端机都会内存溢出开始上代码把 首先我们要拿到图片的所有路径 cursor = context.getContentResolver().query( MediaStore.Images.Media.EXTERNAL_CONTENT_URI, // 大图URI STORE_IMAGES, // 字段 nul...
C# 使用RenderTargetBitmap+drawingVisual生成png长图存在内存泄漏问题
最新发布
log103628的博客
05-29 386
原先使用了使用RenderTargetBitmap+drawingVisual生成png长图，后来发现存在内存泄漏问题，通过各种方式都没办法释放内存，方式如下： /// <summary> /// 生成长图 /// </summary> /// <param name="imageList"></para...
C#打开tif文件时内存溢出（System.OutOfMemoryException）解决办法
热门推荐
超纯的小白兔
10-31 1万+
前言 原创性声明 此博文的出处 为 http://blog.csdn.net/zhujunxxxxx/article/details/39251353如果进行转载请注明出处。本文作者原创，邮箱zhujunxxxxx@163.com，如有问题请联系作者 我在做一个统计图片长和宽的软件时遇到一个问题，本来是用的 Image img = null; img
解决java压缩图片内存溢出问题
lennonlau的博客
12-30 4506
解决java压缩图片内存溢出问题 import java.awt.image.BufferedImage; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.util.Iterator; import javax.imageio.ImageIO; import...
Android防止内存溢出浅析.zip
12-16
以下是对Android防止内存溢出的深入浅析： 1. **Android内存管理机制** - **Dalvik/ART虚拟机**：Android系统使用Dalvik或ART虚拟机执行应用程序，它们都有自己的内存管理策略。 - **堆内存**：Java对象主要存储...
ListView加载网络图片，防止内存溢出
02-10
本篇文章将深入探讨如何在ListView中加载网络图片，并提供策略防止内存溢出。 首先，我们需要理解内存溢出的原因。当一个Android应用分配的内存超过系统允许的最大限制时，就会发生内存溢出。在ListView中加载网络...
Android 图片下载以及内存处理防止OOM内存溢出 源码
10-21
在Android开发中，图片的加载和内存管理是一个关键问题，特别是考虑到防止因内存溢出（Out Of Memory，简称OOM）而导致应用崩溃。本教程将详细探讨如何在Android中有效地进行图片下载和内存处理，以避免OOM的发生。 ...
完美解决java读取大文件内存溢出的问题
08-29
完美解决java读取大文件内存溢出的问题 在Java中读取大文件时，内存溢出是一个常见的问题。传统方式的读取文件方式会将整个文件读取到内存中，导致程序抛出OutOfMemoryError异常。但是，我们可以通过行迭代方式来...
Java图片处理ImageIO.read()问题
04-08
NULL 博文链接：https://o-oand0-0.iteye.com/blog/1585854
图片过大引起的内存溢出解决方案
11-08
使用BitmapFactory加载图片时，如果图片过大可能引起OutOfmemory溢出的问题。解决办法。
图片压缩
yzx41099296的专栏
10-24 690
开发中应用到图片的处理时候，我们通常会怎么缩放操作呢，来看下面的两种做法： 　　方法1：按固定比例进行缩放 　　在开发一些软件，如新闻客户端，很多时候要显示图片的缩略图，由于手机屏幕限制，一般情况下，我们取图片的缩略图，取缩略图的方法我们可以使用BitmapFactory的decodeFile方法，然后通过传递进去 BitmapFactory.Option类型的参数进行取缩略图，在Op
图片内存溢出和图片压缩
小邓(Java)
03-09 1980
1) 要及时回收Bitmap的内存 Bitmap类有一个方法recycle()，从方法名可以看出意思是回收。这里就有疑问了，Android系统有自己的垃圾回收机制，可以不定期的回收掉不使用的内存空间，当然也包括Bitmap的空间。那为什么还需要这个方法呢？ Bitmap类的构造方法都是私有的，所以开发者不能直接new出一个Bitmap对象，只能通过BitmapFactory类的各种静态
html5 image 内存溢出,解决webpack多页面内存溢出的方法示例
weixin_39623244的博客
06-03 218
因为自己的项目是基于vue-cli3进行开发，所以这里只讨论这种情况下的解决办法在进行多页面开发的时候，项目刚开始阶段，因为文件较少，所以代码编译速度还行，但是随着项目逐渐增大，webpack编译的速度越来越慢，并且经常出现内存溢出的情况。下面就是几种尝试的方法，加快编译的速度增加Node运行内存在Node中通过JavaScript使用内存时只能使用部分内存(64位系统下约为1.4 GB，32位系...
PHP垃圾回收深入理解
weixin_30698297的博客
03-06 100
PHP垃圾回收深入理解PHP是一门托管型语言，在PHP编程中程序员不需要手工处理内存资源的分配与释放(使用C编写PHP或Zend扩展除外)，这就意味着PHP本身实现了垃圾回收机制(Garbage Collection)。现在如果去PHP官方网站(php.net)可以看到，目前PHP5的两个分支版本PHP5.2和PHP5.3是分别更新的，这是因为许多项目仍然使用5.2版本的PHP，而5.3版本对5....
javax.imageio.ImageIO.read(file) 内存溢出
cnyanzi_1989的专栏
08-21 1万+
近期使用ImageIO对象生成图片的缩略图功能，无论图片大小，总是会报出以下异常信息： Caused by: java.lang.OutOfMemoryError: Java heap space         at java.awt.image.DataBufferByte.(Unknown Source)         at java.awt.image.ComponentSampl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值