Android 图片压缩详解

最新推荐文章于 2024-08-10 08:10:03 发布
最新推荐文章于 2024-08-10 08:10:03 发布
阅读量3k 收藏 11
点赞数 8
分类专栏： # Android基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fitaotao/article/details/107042468
版权

一、Android中图片的色彩模式

Android中图片是以bitmap形式存在的，那么bitmap所占内存，直接影响到了应用所占内存大小，首先要知道bitmap所占内存大小计算方式：图片宽度 x 图片高度 x 单位像素占用的字节数

以下是图片的色彩模式：其中，A代表透明度；R代表红色；G代表绿色；B代表蓝色。

  • ALPHA_8

表示8位Alpha位图，即A=8，一个像素点占用1个字节，它没有颜色，只有透明度

  • ARGB_4444  @Deprecated

表示16位ARGB位图，即A=4，R=4，G=4，B=4，一个像素点占4+4+4+4=16位，2个字节

  • ARGB_8888  Android默认的色彩模式

表示32位ARGB位图，即A=8，R=8，G=8，B=8，一个像素点占8+8+8+8=32位，4个字节

  • RGB_565

表示16位RGB位图，即R=5，G=6，B=5，它没有透明度，一个像素点占5+6+5=16位，2个字节

  • RGBA_F16

表示64位RGB位图，8个字节

一般情况下我们使用的色彩模式为ARGB_8888，这种模式下一个像素所占的大小为4字节，一个像素的位数总和越高，图像也就越逼真。假设有一张480x800的图片，在色彩模式为ARGB_8888的情况下，会占用 480*800*4/1024KB=1500KB 的内存；而在RGB_565的情况下，占用的内存为：480*800*2/1024KB=750KB。 

二、Android中图片的格式

  • PNG

无损压缩图片格式，支持Alpha(透明)通道，Android切图素材多采用此格式

  • JPEG

有损压缩图片格式，不支持背景透明，适用于照片等色彩丰富的大图压缩，不适合logo，但是文件尺寸较小，下载速度快，更适合网络传输

  • WEBP

是一种同时提供了有损压缩和无损压缩的图片格式，派生自视频编码格式VP8，从谷歌官网来看，无损webp平均比png小26%，有损的webp平均比jpeg小25%~34%，无损webp支持Alpha通道，有损webp在一定的条件下同样支持，有损webp在Android4.0（API 14）之后支持，无损和透明在Android4.3（API18）之后支持

三、Android中的图片压缩方法

Android图片上传是开发中最常见的应用场景之一，但是现在的手机摄像头像素都非常高，随便拍一张照片都在3~6M之间，分辨率也都在3000x4000左右，如此大的照片如果直接显示或者上传到服务器，体验都是非常差的，所以图片在上传之前，一般都要对图片做压缩处理。常用的压缩方法很多，但是归根结底原理上都是围绕 图片宽度 x 图片高度 x 单位像素占用的字节数 这个公式展开的，下面一一展开介绍。

（1）先讲一下图片存在的几种形式：

  • File：存在于我们的磁盘中，我们通常说的图片大小。
  • Stream：即流的形式，比如我们上传网络图片。
  • Bitmap：就是我们通常指内存中图片的大小。

（2）再简单说下位深与色深

图片在内存中和在磁盘上的两种不同的表示形式：前者为Bitmap，后者为各种压缩格式。这里介绍一下位深与色深的概念：

①色深

色深指的是每一个像素点用多少bit来存储ARGB值，属于图片自身的一种属性。色深可以用来衡量一张图片的色彩处理能力（即色彩丰富程度）。典型的色深是8-bit、16-bit、24-bit和32-bit等。上述的Bitmap.Config参数的值指的就是色深。比如ARGB_8888方式的色深为32位，RGB_565方式的色深是16位。

②位深

位深指的是在对Bitmap进行压缩存储时存储每个像素所用的bit数，主要用于存储。由于是“压缩”存储，所以位深一般小于或等于色深 。举个例子：

某张图片100像素*100像素 色深32位(ARGB_8888)，保存时位深度为24位，那么：

该图片在内存中所占大小为：100 * 100 * (32 / 8) Byte。   

在文件中所占大小为 100 * 100 * ( 24/ 8 ) * 压缩率 Byte

 

（3）然后整理下Android中图片读取，显示，修改，保存涉及到的类大致如下图所示：

è¿éåå¾çæè¿°

  • 读取图片文件时，先将图片文件转换为InputStream对象，然后通过BitmapFactory将其转换为Bitmap对象。BitmapFactory提供了四类方法：decodeFile、decodeResource、decodeStream、decodeByteArray
  • 保存图片时，先将Bitmap对象转换为OutputStream对象，然后再将OutputStream输出到文件中
  • 修改图片时，可以通过将Bitmap对象转换为颜色数组（int[]）来修改，也可以通过Canvas来修改。此外Bitmap类提供了一个createBitmap的静态方法，可以通过矩阵变换（Matrix）对Bitmap对象做一些转换或者缩放（到固定的宽高）
  • 显示图片时，可以将Bitmap对象转换为Drawable对象，然后设置给ImageView。

 

1、质量压缩

质量压缩并不会改变图片在内存中的大小，仅仅会减小图片所占用的磁盘空间的大小（File文件的大小），因为质量压缩不会改变图片的分辨率，而图片在内存中的大小是根据width*height*单像素的所占用的字节数计算的，宽高没变，在内存中占用的大小自然不会变，质量压缩的原理是通过改变图片的位深和透明度来减小图片占用的磁盘空间大小，所以不适合作为缩略图，可以用于想保持图片质量的同时减小图片所占用的磁盘空间大小。另外，由于png是无损压缩，所以设置quality无效。

可以通过下面的方法测试验证：

注意：图片在内存中的大小，即Bitmap的大小，计算方式是：宽*高*单像素字节数。它与图片文件在磁盘中的存在形式，即File的大小是两个概念（它和图片流的大小是一致的），是不一样的，不能直接拿他们两比较大小。图片在磁盘中的大小跟图片格式和压缩率有关。图片在内存中的大小只和分辨率宽，高，以及单像素字节数有关。二者之间没有关联。测试方法：设置compress方法的quality值为100，不压缩，格式为JPEG，然后比较压缩前后的磁盘中图片大小，以及下面方法中Bitmap内存中占用内存大小。

//(1)测试最初加载到内存中的Bitmap大小
/** 测算Bitmap压缩前在内存中的大小，与预算结果一致，计算方法为：Width * Height * 4 / 1024 KB */
/** {@link android.graphics.Bitmap.Config#ARGB_8888}，Android默认色彩模式，单位像素占用字节数为4 */
LogUtils.e("Bitmap.Size.Original：" + bitmap.getAllocationByteCount() / 1024 + "KB" + "\tWidth：" + bitmap.getWidth() + "\tHeight：" + bitmap.getHeight());

//(2)获取Bitmap通过质量压缩后输出流的大小
//注意：这里即便quality设置为100，比起(1)的大小也会被压缩变小，因为本质上是一种压缩存储。不过这
//两个大小没有可比性，一个是占内存大小，一个是占磁盘存储大小
//所以关于参数quality的认知，100意义上是不压缩
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 50, byteArrayOutputStream);
LogUtils.e("Bitmap.Size.Compressed.Stream：" + byteArrayOutputStream.toByteArray().length / 1024 + "KB");

//(3)这里再加载到内存中的大小和(1)测试的大小一致，表明质量压缩并不会改变图片在内存中的大小
Bitmap testBitmap = BitmapFactory.decodeByteArray(byteArrayOutputStream.toByteArray(), 0, byteArrayOutputStream.toByteArray().length);
LogUtils.e("Bitmap.Size.testBitmap：" + testBitmap.getAllocationByteCount() / 1024 + "KB");

//(4)将内存中的Bitmap通过流输出保存到本地文件
//这里quality也取50，打印出压缩并转换后的File大小，与(2)中流的大小完全一致
//最后查看本地文件的大小与(2)中输出流大小基本一致，但是会大一些，原因暂未深究
File file = new File(fileName);
FileOutputStream outputStream = new FileOutputStream(file);
convertResult = bitmap.compress(Bitmap.CompressFormat.JPEG, 50, outputStream);
LogUtils.e("Bitmap.Size.Compressed.File：" + file.length() / 1024 + "KB");


//(5)如果这里的压缩格式改成PNG格式，则无论quality取值为何值，压缩后的大小不变，因为它是无损的
//压缩为PNG可以理解为图片编辑另存为PNG格式，是会改变图片编码结构的，不同于改后缀名
//而且PNG格式的图片文件大小是会比JPEG大一些的，接近一倍(简单测试了几组，参考即可)
//bitmap.compress(Bitmap.CompressFormat.PNG, 50, byteArrayOutputStream);

使用场景：将压缩后的图片上传到服务器，或者保存到本地。核心方法是：

bitmap.compress(format,quality, outputstream);
//参数说明：

//1.使用此方法压缩bitmap以后，图片的宽高大小都不会变化，每个像素大小也不会变化，所以图片在内存中的实际大小不会变化

//2.第一个参数Bitmap.CompressFormat format ：是图像的压缩格式，可以理解为图片编辑后另存为的格式
//如果是Bitmap.CompressFormat.PNG，那不管第二个值如何变化，图片大小都不会变化，不支持png图片的压缩

//3.第二个参数是压缩比重，图片存储在磁盘上的大小会根据这个值变化，值越小存储在磁盘的图片文件越小
//关于参数quality的认知，100意义上是不压缩

具体实现如下：

PS：一般图片压缩通用流程：先进行尺寸压缩，然后在进行质量压缩，然后看照片是否有旋转角度，如果有，旋转一下，最后返回处理后的照片路径，在进行上传或者保存。

/**
     * 图片压缩监听接口
     */
    public interface ImageCompressListener {
        void onSuccess(File file);

        void onError(String msg);
    }



/**
     * 图片压缩-Android原生只质量压缩
     *
     * @param imgPath          图片路径
     * @param compressFileName 压缩后的文件名，不用带目录和后缀(如.png或者.jpg)
     * @param targetSize       要求压缩后的图片大小，单位：KB
     * @param listener         压缩结果监听
     */
    public static void qualityCompress(String imgPath, String compressFileName, int targetSize, ImageCompressListener listener) {
        Bitmap bitmap = null;
        try {
            //避免图片加载占用过大内存导致崩溃
            bitmap = BitmapFactory.decodeFile(imgPath);
            bitmap = rotatePicByDegree(bitmap, getPictureDegree(imgPath));
        } catch (OutOfMemoryError e) {
            listener.onError("The bitmap has out of memory：" + e.getMessage());
            return;
        }

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
        int quality = 90;
        //这里也可以设置为quality >= 0，这样可以压到最小，但是也不一定就能满足targetSize
        while (byteArrayOutputStream.toByteArray().length / 1024 > targetSize && quality > 0) {
            byteArrayOutputStream.reset();
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, byteArrayOutputStream);
            Log.d("Bitmap.Size.Comp.Str：", byteArrayOutputStream.toByteArray().length / 1024 + "KB" + "\t" + "quality = " + quality);
            quality -= 10;
        }

        FileUtils.makeDirs(IMAGE_SAVE_DIR);
        String child = compressFileName + ".jpg";
        File file = new File(IMAGE_SAVE_DIR, child);
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            byteArrayOutputStream.writeTo(fileOutputStream);
//            fileOutputStream.write(byteArrayOutputStream.toByteArray());//或者這樣
            fileOutputStream.flush();
            fileOutputStream.close();
            byteArrayOutputStream.close();
            Log.e("Bitmap.Size.Compressed：", file.length() / 1024 + "KB");
            listener.onSuccess(file);

        } catch (IOException e) {
            e.printStackTrace();
            listener.onError(e.getMessage());
        }
        bitmapRecycle(bitmap);
    }

 

2、采样率压缩

采样率压缩的原理是，通过设置BitmapFactory.Options.inSampleSize的值，请求解码器对原始图像进行二次采样图像，返回较小的图像以节省内存。   如果设置为大于1的值，则 样本大小是任一维度中与已解码位图中单个像素相对应的像素数。 例如，inSampleSize == 4，则返回图像的宽度和高度，是原始图像的1/4，然后总像素数目变为原来的1/16。 任何小于等于1的值都与1相同。注意：解码器使用基于2的幂的最终值，任何其他值将向下四舍五入为最接近的2的幂。如设置inSampleSize为7，则实际上取值为4。此处为了绝对保证压缩后的图片绝对小于或者等于设置的宽和高，直接取了最精确的inSampleSize值，而没有通过当前宽除以要求宽的方式来计算nSampleSize值，主要也是为了避免四舍五入后带来的误差。

/**
     * 图片压缩-Android原生只尺寸压缩
     * 但是实际上{@link #bitmapToFile 方法中还是有调用compress的质量压缩，只是取了最高quality:100}
     * 一般通用完整流程：先进行尺寸压缩，然后在进行质量压缩，然后看照片是否有旋转角度，如果有，rotate一下，最后返回处理后的照片路径
     *
     * @param imgPath          图片路径
     * @param compressFileName 压缩后的文件名，不用带目录和后缀(如.png或者.jpg)
     * @param reqWidth         要求压缩后的图片宽度
     * @param reqHeight        要求压缩后的图片高度
     * @param listener         压缩结果监听
     */
    public static void sizeCompress(String imgPath, String compressFileName, int reqWidth, int reqHeight, ImageCompressListener listener) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;//开始读入图片
        Bitmap bitmap = BitmapFactory.decodeFile(imgPath, options);//此时返回bitmap为空
        int width = options.outWidth;
        int height = options.outHeight;
        options.inJustDecodeBounds = false;

        //计算采样率
        int sampleSize = 1;//压缩比例
        while ((width / sampleSize > reqWidth) || (height / sampleSize > reqHeight)) {
            sampleSize *= 2;
        }
        options.inSampleSize = sampleSize;

        try {
            bitmap = BitmapFactory.decodeFile(imgPath, options);//加载采样率压缩后的图片到内存
        } catch (OutOfMemoryError e) {
            listener.onError("The bitmap has out of memory：" + e.getMessage());
            return;
        }
        bitmap = rotatePicByDegree(bitmap, getPictureDegree(imgPath));//将图片旋转为正常角度

        //保存压缩后的图片到本地
        FileUtils.makeDirs(IMAGE_SAVE_DIR);
        String child = compressFileName + ".jpg";
        if (bitmapToFile(bitmap, child)) {
            listener.onSuccess(new File(IMAGE_SAVE_DIR, child));
        } else {
            listener.onError("image_compress_failed");
        }
        bitmapRecycle(bitmap);
    }

 

3、矩阵变换缩放压缩

顾名思义，其实原理就是通过矩阵变换将Bitmap的长宽精确缩放到你设置的尺寸。下面做图片旋转的方法本质也是通过矩阵变换来实现的。

/**
 * android.graphics.Bitmap的原生方法
 * 参数二是你要设置的宽度，参数三是你要设置的高度
 * 参数四，设置为true，则会在你设置的尺寸附近，如果牺牲很小的尺寸代价可以得到更好的图片质量，
 * 系统就会默认选择最好的质量；设置为false，则严格按照你设置的宽高来，不考虑图片质量，压缩更快。
 */
public static Bitmap createScaledBitmap(@NonNull Bitmap src, int dstWidth, int dstHeight,
            boolean filter) {
        Matrix m = new Matrix();

        final int width = src.getWidth();
        final int height = src.getHeight();
        if (width != dstWidth || height != dstHeight) {
            final float sx = dstWidth / (float) width;
            final float sy = dstHeight / (float) height;
            m.setScale(sx, sy);
        }
        return Bitmap.createBitmap(src, 0, 0, width, height, m, filter);
    }

 

4、修改色彩模式压缩方法

原理就是通过修改图片的色彩模式来改变单像素占用内存字节数，进而实现压缩图片的方法。不同图片色彩模式占用的字节大小在第一部分已有讲解。原理比较简单，可参考采样率压缩方法，这里只列出来重要的，不再赘述。

    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inPreferredConfig = Config.RGB_565;
    Bitmap bitmap = BitmapFactory.decodeFile(imgPath, options);

RGB_565压缩是通过改用内存占用更小的编码格式来达到压缩的效果。Android默认的颜色模式为ARGB_8888，这个颜色模式色彩最细腻，显示质量最高。一般不建议使用ARGB_4444，因为画质实在是不好，如果对透明度没有要求，建议可以改成RGB_565，相比ARGB_8888将节省一半的内存开销。

 

 

5、第三方压缩框架


/**
 * 导入依赖，https://github.com/Curzibn/Luban
 */
    implementation 'top.zibin:Luban:1.1.8'


/**
     * 图片压缩-Luban压缩
     *
     * @param context
     * @param imgPath  图片本地路径
     * @param listener
     */
    public static void lubanCompress(Context context, @NonNull String imgPath, ImageCompressListener listener) {

        FileUtils.makeDirs(IMAGE_SAVE_DIR);
        File file = new File(imgPath);
        if (!file.exists()) {
            listener.onError(context.getResources().getString(R.string.file_not_exist));
            return;
        }
        Luban.with(context)
                .load(file)
                .ignoreBy(300)
                .setTargetDir(IMAGE_SAVE_DIR)
                .setCompressListener(new OnCompressListener() {
                    @Override
                    public void onStart() {

                    }

                    @Override
                    public void onSuccess(File file) {
                        listener.onSuccess(file);
                    }

                    @Override
                    public void onError(Throwable e) {
                        listener.onError(e.getMessage());
                    }
                })
                .launch();
    }

 

6、Android原生通用压缩方法：质量压缩+采样率压缩

先尺寸压缩，再质量压缩：

    /**
     * 图片压缩-Android原生
     * 先进行尺寸压缩，加载到内存中后看照片是否有旋转角度，进行旋转，再进行质量压缩，最后保存本地
     *
     * @param imgPath          图片路径
     * @param compressFileName 压缩后的文件名，不用带目录和后缀(如.png或者.jpg)
     * @param reqWidth         要求压缩后的图片宽度
     * @param reqHeight        要求压缩后的图片高度
     * @param targetSize       要求压缩后的图片大小，单位：KB
     * @param listener         压缩结果监听
     */
    public static void commonCompress(@NonNull String imgPath, @NonNull String compressFileName, @NonNull int reqWidth, @NonNull int reqHeight,
                                      @NonNull int targetSize, @NonNull ImageCompressListener listener) {

        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeFile(imgPath);
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        options.inJustDecodeBounds = false;

        int sampleSize = 1;
        while ((width / sampleSize > reqWidth) || (height / sampleSize > reqHeight)) {
            sampleSize *= 2;
        }
        options.inSampleSize = sampleSize;
        try {
            bitmap = BitmapFactory.decodeFile(imgPath, options);
        } catch (OutOfMemoryError e) {
            listener.onError("The bitmap has out of memory：" + e.getMessage());
            return;
        }
        //角度旋转
        bitmap = rotatePicByDegree(bitmap, getPictureDegree(imgPath));

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
        int quality = 90;
        while (byteArrayOutputStream.toByteArray().length / 1024 > targetSize && quality >= 0) {
            byteArrayOutputStream.reset();//重置
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, byteArrayOutputStream);
            quality -= 10;
        }

        String child = compressFileName + ".jpg";
        File file = new File(IMAGE_SAVE_DIR, child);
        try {
            FileOutputStream outputStream = new FileOutputStream(file);
            byteArrayOutputStream.writeTo(outputStream);
//            outputStream.write(byteArrayOutputStream.toByteArray());//或者这样
            outputStream.flush();
            outputStream.close();
            byteArrayOutputStream.close();
            Log.e("Bitmap.Size.Compressed：", file.length() / 1024 + "KB");
            listener.onSuccess(file);

        } catch (IOException e) {
            e.printStackTrace();
            listener.onError(e.getMessage());
        }
        bitmapRecycle(bitmap);
    }

 

下面放上其余的通用方法：图片旋转，获取图片旋转角度，Bitmap转文件保存本地，Bitmap内存回收

/**
     * 将图片按照某个角度进行旋转
     *
     * @param bitmap 待旋转图片
     * @param degree 旋转角度
     * @return 旋转后的图片
     */
    public static Bitmap rotatePicByDegree(Bitmap bitmap, int degree) {
        Bitmap rotateBitmap = null;
        //根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);
        try {
            // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
            rotateBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);

        } catch (OutOfMemoryError e) {
            e.printStackTrace();
        }

        if (rotateBitmap == null) {
            rotateBitmap = bitmap;
        }

        //注意：如果你给的宽高和oldBitmap一样，newBitmap就是oldBitmap，调用recycle()之后
        //你的newBitmap 也就被recycle()而不能用了。
        if (bitmap != rotateBitmap) {
            bitmap.recycle();
            bitmap = null;
        }
        return rotateBitmap;
    }


    /**
     * 获取图片的旋转角度
     * 手机拍照的图片，本地查看正常的照片，传到服务器发现照片旋转了90°或者270°，这是因为有些手机摄像头的参数原因，拍出来的照片是自带旋转角度的
     *
     * @param imgPath 本地图片路径
     * @return 图片旋转角度
     */
    public static int getPictureDegree(String imgPath) {
        int degree = 0;
        try {
            //获取图片的exif信息，exif是照片的一些头部信息，如拍照时间，相机品牌，型号，色彩编码，旋转角度等
            ExifInterface exifInterface = new ExifInterface(imgPath);
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return degree;
    }


    /**
     * bitmap格式转文件
     * 存在质量压缩
     *
     * @param bitmap   待转换bitmap
     * @param fileName 本地文件名，默认不带后缀，需要调用者自己加
     * @return true 转换成功
     */
    public static boolean bitmapToFile(Bitmap bitmap, String fileName) {
        if (bitmap == null || bitmap.isRecycled()) {
            return false;
        }
        if (TextUtils.isEmpty(fileName)) {
            return false;
        }
        boolean convertResult = false;
        FileUtils.makeDirs(IMAGE_SAVE_DIR);
        File file = new File(IMAGE_SAVE_DIR, fileName);
        FileOutputStream outputStream = null;

        try {
            /** 测算Bitmap压缩前在内存中的大小，与预算结果一致，计算方法为：Width * Height * 4 / 1024 KB */
            /** {@link android.graphics.Bitmap.Config#ARGB_8888}，Android默认色彩模式，单位像素占用字节数为4 */
            Log.e("Bitmap.Size.Original：", bitmap.getAllocationByteCount() / 1024 + "KB" + "\tWidth：" + bitmap.getWidth() + "\tHeight：" + bitmap.getHeight());

            outputStream = new FileOutputStream(file);
            convertResult = bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
            Log.e("Bitmap.Size.Compressed：", file.length() / 1024 + "KB");

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (outputStream != null) {
                    outputStream.flush();
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return convertResult;
    }

    /**
     * Bitmap内存回收
     *
     * @param bitmaps 准备回收内存的Bitmaps
     */
    public static void bitmapRecycle(Bitmap... bitmaps) {
        if (bitmaps == null) {
            return;
        }
        for (Bitmap bitmap : bitmaps) {
            if (bitmap != null && !bitmap.isRecycled()) {
                bitmap.recycle();
            }
        }
    }


    /**
     * 创建文件目录
     */
    public static boolean makeDirs(String dir){
        File file = new File(dir);
        if (!file.exists()) {
          return  file.mkdirs();
        }
        return true;
    }

 

四、Bitmap的回收

我们在做App内存优化的时候，一般可以从两个方面入手，一个内存泄漏，另外一个是压缩且只使用一次的Bitmap，要及时做好recycle的处理。这里就简单说说BItmap的内存回收。

 

 

附：Android 图片格式JPEG与PNG

Android中一张图片占用的内存大小

 

 

 

残风乱了温柔
关注
专栏目录
Android 的图片压缩
Theprogramleaders的博客
09-06 510
我用的图片主要分为3种       1、质量压缩 ，2、尺寸压缩，3、Luban压缩（鲁班） 一、质量压缩    质量压缩的特点是:  File形式的图片确实被压缩了, 但是当你重新读取压缩后的file为 Bitmap是,它占用的内存并没有改变              质量压缩主要借助Bitmap中的compress方法实现： public boolean compress (Bitm...
android图片压缩总结
热门推荐
潜移默化...
07-07 7万+
首先该文章是总结, 不是研究, 是通过看网上其他大神的文章和自己的一些实践总结出来的.  一.图片的存在形式 1.文件形式(即以二进制形式存在于硬盘上) 2.流的形式(即以二进制形式存在于内存中) 3.Bitmap形式 这三种形式的区别: 文件形式和流的形式对图片体积大小并没有影响,也就是说,如果你手机SD卡上的如果是100K,         那么通过流的形式读到内存中,也一
探索高效图片压缩神器：AdvancedLuban
最新发布
gitblog_00453的博客
08-10 219
探索高效图片压缩神器：AdvancedLuban AdvancedLubanAn Advanced Compress Image Library for Android / 高效、简洁的图片压缩工具库 项目地址:https://gitcode.com/gh_mirrors/ad/AdvancedLuban 在移动应用开发中，图片压缩是一个不可或缺的环节。无论是为了提升用户体验，还是为了优化应用性...
Android压缩
smallredzi的博客
12-27 551
android视频压缩 效果图 选择当前视频大小为 65.57MB 压缩有三种方式 分别对应的是 High Mediunm Low 上面用的是Low 最小的 public static VideoCompressTask compressVideoHigh(String srcPath, String destPath, CompressListener liste...
android压缩
weixin_43303514的博客
11-02 369
关于视频压缩有以下几种方式可选： 第一种：使用FFmpeg 缺点： 1.压缩效率低，时间长，使用繁琐，增大apk体积 2.如果只是对视频进行压缩，不建议使用FFmpeg 第二种：使用七牛SDK 七牛短视频SDK链接： https://developer.qiniu.com/sdk#official-sdk 缺点：收费，只能试用，测试的结果：隔天就会提示未经授权 PLDroidShortVideo: Pili-System:unauthorized ! compressVideoResouce: transc
(Android) Compress Bitmap
palmerma的专栏
09-15 736
private Bitmap compressImage(Bitmap image) {              ByteArrayOutputStream baos = new ByteArrayOutputStream();           image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不
Android图片压缩的实例详解
08-29
"Android图片压缩的实例详解" Android图片压缩是移动应用开发中非常重要的一部分，今天我们来详细介绍Android图片压缩的实例详解。Android图片压缩主要有两种方式：压缩图片分辨率与压缩图片质量。压缩图片分辨率是...
Android中图片压缩方案详解样本.doc
11-18
本篇文章将详细解析两种常见的Android图片压缩方案：质量压缩法和采样率压缩法。 1. **质量压缩法** 质量压缩法是通过调整图片的位深度和透明度来减小文件大小，而不改变图片的像素数量。这种方法适用于那些对图片...
详解Android 图片的三级缓存及图片压缩
09-01
Android图片的三级缓存策略能够有效地平衡性能、内存使用和流量消耗。同时，合理的图片压缩技术可以进一步优化资源利用。开发者需要根据实际需求选择合适的缓存策略和压缩方式，以提供流畅的用户体验同时减少资源...
Android中图片压缩方案详解及源码下载
01-20
Android中图片压缩方案详解及源码下载 图片的展示可以说在我们任何一个应用中都避免不了，可是大量的图片就会出现很多的问题，比如加载大图片或者多图时的OOM问题，可以移步到Android高效加载大图及多图避免程序OOM....
Android压缩工具
weixin_34194551的博客
04-05 250
2019独角兽企业重金招聘Python工程师标准>>> ...
Android代码-CompressTools-Android
08-06
CompressTools-Android 压缩，图片压缩，压缩Bitmap 特性： *这是和微信压缩效果类似的压缩方式，采用底层压缩。 *尽量无损压缩图片，保持清晰度最优。可以对比原生方法bitmap.compress(CompressFormat.JPEG, quality, fileOutputStream); *占用内存少，支持压缩生成原图分辨率图片； *支持批量压缩，采用线程池提高性能 *支持压缩监听回调 *支持返回Bitmap和File 不支持x86架构 对比： ImageInfo compressTool Wechat 1.50MB (1920x1080) 47.32kb(1280*720) 51.4kb(1280*720) 放两张效果图，大家可以看看效果是不是一样的。尺寸大小几乎一模一样！大家可以down下来，查看一下。 这个是微信压缩后的图片： 这个是采用该库压缩后的图片： 使用方法： compile 'com.jaywei:compresstool:1.2.1' 1.2.1： 优化线程池 *1和2使用默认设置，默认设置最大宽高为720960*
Android 图片压缩
leilifengxingmw的博客
07-04 538
首先扯点别的：最近上海的天气也是热的不得了，早上跑步也不合适了，中午吃饭也没胃口。 今天记录一下Android中的图片压缩。注意，为了简单，代码中需要的读写存储空间的权限已经在上一个页面申请过了。 尺寸压缩 改变图片的尺寸，比如说原来是1280×1902的变成640×320的。压缩图片的尺寸可以减少图片占用的内存大小。 获取一个Bitmap占用内存大小的方法，可以使用Bitmap的ge...
android compress函数,Linux Kernel(Android) 加密算法小结（cipher、compress、digest）
weixin_40001967的博客
05-25 349
Linux Kernel(Android) 加密算法总结(cipher、compress、digest)1. Linux内核支持哪些加密算法 ？内核支持的加密算法很多，包括：对称加密算法，如AES；摘要算法，如sha1,md5；压缩算法，如deflate。不过内核好像不支持非对称加密算法。2. 加密算法源文件位置这些算法作为加密函数框架的最底层，提供加密和解密的实际操作。这些函数可以在内核cryp...
Android性能优化之图片压缩优化
chenliguan的博客
01-13 1万+
1 分类 Android图片压缩结合多种压缩方式，常用的有尺寸压缩、质量压缩、采样率压缩以及通过JNI调用libjpeg库来进行压缩。 参考此方法：Android-BitherCompress 备注：对于资源图片直接使用：tiny压缩 2 质量压缩 （1）原理：保持像素的前提下改变图片的位深及透明度，（即：通过算法抠掉(同化)了图片中的一些某个些点附近相近的像素），达到降低质量压缩文件大...
Android compress图片压缩介绍
iteye_20236的博客
03-01 464
        android的照相功能随着手机硬件的发展，变得越来越强大，能够找出很高分辨率的图片。有些场景中，需要照相并且上传到服务，但是由于图片的大小太大，那么就上传就会很慢(在有些网络情况下)，而且很耗流量，要想速度快，那么就需要减小图片的大小。减少图片的大小有两种方法，1. 照小图片； 2. 压缩大图片。 照相时获取小图片一般不太符合要求，因为，图片的清晰度会很差，但是这种情况有个好处...
Android-图片压缩详解：原理、方法与实践
沐雨风栉
05-04 5470
在Android应用开发中，处理图片是一个非常常见的需求。然而，大尺寸和高质量的图片可能会占用大量内存，导致应用程序性能下降，甚至引发OOM（Out of Memory）错误。因此，对图片进行合适的压缩是非常重要的。本文将详细介绍Android图片压缩的原理、方法和实践。在本文中，我们详细介绍了Android图片压缩的原理、方法和实践。我们学习了如何使用BitmapFactory.Options进行尺寸压缩和质量压缩，以及如何使用第三方库进行图片压缩。
Android开发之图片压缩处理，闭关在家37天“吃透”这份345页PDF
m0_63935374的博客
11-11 1194
private Luban build() { return new Luban(this); } } 我们看到了是一个静态的内部类Builder，我们这里看到了有5个变量，上面我们说道了，为了减少初始化数据的代码，就拿这个举例子说明，我如果有4个地方调用这个鲁班压缩，其中这4个地方，mTargetDir，mLeastCompressSize这2个变量的值都是一样的，其他3个不一样，按照我们以往的写法都得一个一个的赋值，要写4遍，那如果使用建造者模式了，这里就只用写一遍赋值，这2个变量。其他3个不一样，就得
ARGB颜色格式学习
q1449660223的博客
11-29 1万+
概述 RGB RGB(Alpha,Red,Green,Blue)色彩模式是工业界的一种颜色标准，是通过对红®、绿(G)、蓝(B)三个颜色通道的变化以及它们相互之间的叠加来得到各式各样的颜色的，RGB即是代表红、绿、蓝三个通道的颜色，这个标准几乎包括了人类视力所能感知的所有颜色，是目前运用最广的颜色系统之一。RGB图像只使用三种颜色，就可以使它们按照不同的比例混合，在屏幕上呈现16777216(256 * 256 * 256)种颜色 ARGB 一种色彩模式，也就是RGB(Alpha,Red,Green,Blu
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值