精华内容
下载资源
问答
  • 安卓压缩图片

    2013-05-24 18:14:38
    为避免Android内存溢出,特地采用了此方法来避免。通过压缩图片,提高应用的稳定性
  • 关于安卓压缩图片

    2018-04-16 16:49:54
    总结遇坑过程想保存Glide的缓存图片(失败)一开始是想用Glide的硬盘缓存图片的,不过他计算的key值无法获取到(或许我不会),那就无法知道文件名字,这方法不行自己用BitmapFactory压缩(忽大忽小)上网看...

    遇坑过程

    想保存Glide的缓存图片(失败)

    一开始是想用Glide的硬盘缓存图片的,不过他计算的key值无法获取到(或许我不会),那就无法知道文件名字,这方法不行

    自己用BitmapFactory压缩(忽大忽小)

    上网看https://blog.csdn.net/jdsjlzx/article/details/44228935,用BitmapFactory压缩,效果是有些图片是尺寸是会变小,可是有些体积反而变大了(这也不太对)

    下面是核心代码的使用demo

    使用方法save(getimage(imagePath), Environment.getExternalStorageDirectory()+"/2.png", Bitmap.CompressFormat.PNG);

    
        /**
         * 图片按比例大小压缩方法
         *
         * @param srcPath (根据路径获取图片并压缩)
         * @return
         */
        public static Bitmap getimage(String srcPath) {
    
            BitmapFactory.Options newOpts = new BitmapFactory.Options();
            // 开始读入图片,此时把options.inJustDecodeBounds 设回true了
            newOpts.inJustDecodeBounds = true;
            Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此时返回bm为空
    
            newOpts.inJustDecodeBounds = false;
            int w = newOpts.outWidth;
            int h = newOpts.outHeight;
            float hh = 2560f;// 图片最大的高度为
            float ww = 1440f;// 图片最大的宽度为
            // 缩放比。由于是固定比例缩放,只用高或者宽其中一个数据进行计算即可
            int be = 1;// be=1表示不缩放
            if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
                be = (int) (newOpts.outWidth / ww);
            } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
                be = (int) (newOpts.outHeight / hh);
            }
            if (be <= 0)
                be = 1;
            newOpts.inSampleSize = be;// 设置缩放比例
            // 重新读入图片,注意此时已经把options.inJustDecodeBounds 设回false了
            bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
            return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩
        }
    
        /**
         * 质量压缩方法
         *
         * @param image
         * @return
         */
        public static Bitmap compressImage(Bitmap image) {
    
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            image.compress(Bitmap.CompressFormat.JPEG, 100, baos);// 质量压缩方法,这里100表示不压缩,把压缩后的数据存放到baos中
            int options = 90;
    
            while (baos.toByteArray().length / 1024 > 100) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
                baos.reset(); // 重置baos即清空baos
                image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%,把压缩后的数据存放到baos中
                options -= 10;// 每次都减少10
            }
            ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
            Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
            return bitmap;
        }
    
        /**
         * 保存图片
         *
         * @param src      源图片
         * @param filePath 要保存到的文件路径
         * @param format   格式
         * @return {@code true}: 成功<br>{@code false}: 失败
         */
        public static boolean save(Bitmap src, String filePath, Bitmap.CompressFormat format) throws IOException {
            return save(src, (new File(filePath)), format);
        }
    
        /**
         * 保存图片
         *
         * @param src    源图片
         * @param file   要保存到的文件
         * @param format 格式
         * @return {@code true}: 成功<br>{@code false}: 失败
         */
        public static boolean save(Bitmap src, File file, Bitmap.CompressFormat format) throws IOException {
            return save(src, file, format, false);
        }
    
        /**
         * 保存图片
         *
         * @param src      源图片
         * @param filePath 要保存到的文件路径
         * @param format   格式
         * @param recycle  是否回收
         * @return {@code true}: 成功<br>{@code false}: 失败
         */
        public static boolean save(Bitmap src, String filePath, Bitmap.CompressFormat format, boolean recycle) throws IOException {
            return save(src, (new File(filePath)), format, recycle);
        }
    
        /**
         * 保存图片
         *
         * @param src     源图片
         * @param file    要保存到的文件
         * @param format  格式
         * @param recycle 是否回收
         * @return {@code true}: 成功<br>{@code false}: 失败
         */
        public static boolean save(Bitmap src, File file, Bitmap.CompressFormat format, boolean recycle) throws IOException {
            if (isEmptyBitmap(src) || file.exists()) return false;
            System.out.println(src.getWidth() + ", " + src.getHeight());
            OutputStream os = null;
            boolean res = false;
            try {
                os = new BufferedOutputStream(new FileOutputStream(file));
                res = src.compress(format, 100, os);
                if (recycle && !src.isRecycled()) src.recycle();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                os.close();
            }
            return res;
        }
    
        /**
         * 判断bitmap对象是否为空
         *
         * @param src 源图片
         * @return {@code true}: 是<br>{@code false}: 否
         */
        private static boolean isEmptyBitmap(Bitmap src) {
            return src == null || src.getWidth() == 0 || src.getHeight() == 0;
        }

    最后Luban完美解决

    最后看到https://github.com/Curzibn/Luban/blob/master/README.md,使用Luban压缩,可以完美解决问题

    Luban.with(this)
                        .load(path1)                                   // 传人要压缩的图片列表
                        .ignoreBy(100)                                  // 忽略不压缩图片的大小
                        .setTargetDir(Environment.getExternalStorageDirectory()+"/aaaaa")                        // 设置压缩后文件存储位置
                        .setCompressListener(new OnCompressListener() { //设置回调
                            @Override
                            public void onStart() {
                                // TODO 压缩开始前调用,可以在方法内启动 loading UI
                            }
    
                            @Override
                            public void onSuccess(File file) {
                                // TODO 压缩成功后调用,返回压缩后的图片文件
                                Log.d(TAG, "onSuccess: "+file.exists());
                            }
    
                            @Override
                            public void onError(Throwable e) {
                                // TODO 当压缩过程出现问题时调用
                                Log.d(TAG, "onError: "+e);
                            }
                        }).launch();    //启动压缩

    总结

    因为以前也没想过与研究压缩图片的事情,一开始时候一直想的事情是控制图片尺寸,最后发现尺寸一样的图片,人看上去也一样的图片,而大小可能相差很大。

    展开全文
  • 这个类非常好用,参数可调。对于开发图片类相关程序比较有帮助
  • 安卓开发中有一个非常常用的功能就是上传图片了,但往往图片较大,而安卓屏幕较小,不需要过高的分辨率,我们需要压缩一下在发送到服务器这样可以减少服务器的存储压力和减少网络的使用。 下面是服务端的代码就是...

    在安卓开发中有一个非常常用的功能就是上传图片了,但往往图片较大,而安卓屏幕较小,不需要过高的分辨率,我们需要压缩一下在发送到服务器这样可以减少服务器的存储压力和减少网络的使用。

    下面是服务端的代码就是要获取到一个IFormFile对象就行了,这样就能或得到流,然后我们通过流写到服务器所在的机器硬盘里就可以了。文件名我们用随机数生成就可以了。

    using System;
    using System.IO;
    using System.Text;
    using Microsoft.AspNetCore.Http;
    using Microsoft.AspNetCore.Mvc;
    namespace Secondhandmarket.Controllers
    {
        [Route("api/[controller]")]
        [Controller]
        public class UploadController : Controller
        {
            [HttpPost("load")]
            [HttpPost]
            public ActionResult UploadImg([FromForm(Name = "file")] IFormFile file)
            {
                //获得当前项目wwwroot/image的绝对路径
                var appPath = AppContext.BaseDirectory.Split("\\bin\\")[0] + "/wwwroot/image/";
                try
                {
                        if (file != null)
                        {
                            string url = appPath + "/" + createSmallAbc()+".png";
                            //文件后缀
                            var fileExtension = Path.GetExtension(file.FileName);
                            //判断后缀是否是图片
                            const string fileFilt = ".gif|.jpg|.jpeg|.png";
                            if (fileFilt.IndexOf(fileExtension.ToLower(), StringComparison.Ordinal) <= -1)
                            {
                                return null;
                            }
                            //将文件写入磁盘
                            using (FileStream fs = System.IO.File.Create(url))
                            {
                                file.CopyTo(fs);
                                fs.Flush();
                                return Json(new { msg = "success" });
                            }
                        }
                        return Json(new { msg = "faild" });
    
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                    return Json(new { msg = "faild"});
                }
            }
    
            /**
             *生成随机数 
             */
            private string createSmallAbc()
            {
                StringBuilder stringBuilder = new StringBuilder("");
                for (int i = 0; i < 4; i++)
                {
                    Random random = new Random(Guid.NewGuid().GetHashCode());
                    int num = random.Next(97, 123);
                    string abc = Convert.ToChar(num).ToString();
                    stringBuilder.Append(abc);
                }
    
                return stringBuilder.ToString();
            }
        }
    }

     

     [FromForm(Name = "file")]表示我们要接受表单里的文件数据,所以我们在安卓端发送表单post请求就可以了

    private static void uploadImage(String url,File file){
            String imagePath = file.getAbsoluteFile().toString();
            Log.d(TAG,"file.getPah:"+imagePath);
            OkHttpClient okHttpClient = new OkHttpClient();
            RequestBody image = RequestBody.create(MediaType.parse("image/jpg"), file);
            RequestBody requestBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM)
                    .addFormDataPart("file", imagePath, image)
                    .build();
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            okHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    e.printStackTrace();
                }
    
                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    String responseStr = response.body().string();
                    Log.d(TAG, "onResponse: "+responseStr);
                }
            });
        }
    
        private static void uploadImage(String url, String imagePath,float desWidth) {
            Log.d("imagePath", imagePath);
            //下面这两句是用于压缩的,不需要的话可以直接删除掉
            Bitmap compressbitmap = CompressImageUtil.compressImageFromFile(imagePath,desWidth);
            File file = CompressImageUtil.compressImage(compressbitmap);
            //调用重载,发送post请求
            uploadImage(url,file);
        }

    我们用了OkHttp3发送请求,这样后台就能收到了。

    下面是压缩

    package com.example.myapplication.util;
    
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.os.Environment;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class CompressImageUtil {
    
        public static Bitmap compressImageFromFile(String srcPath, float desWidth) {
            BitmapFactory.Options newOpts = new BitmapFactory.Options();
            newOpts.inJustDecodeBounds = true;//只读边,不读内容
            Bitmap bitmap;
            bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
            newOpts.inJustDecodeBounds = false;
            int w = newOpts.outWidth;
            int h = newOpts.outHeight;
            float desHeight = desWidth * h / w;
            int be = 1;
            if (w > h && w > desWidth) {
                be = (int) (newOpts.outWidth / desWidth);
            } else if (w < h && h > desHeight) {
                be = (int) (newOpts.outHeight / desHeight);
            }
            if (be <= 0)
                be = 1;
            newOpts.inSampleSize = be;//设置采样率
    
    //        newOpts.inPreferredConfig = Config.ARGB_8888;//该模式是默认的,可不设
            newOpts.inPurgeable = true;// 同时设置才会有效
            newOpts.inInputShareable = true;//。当系统内存不够时候图片自动被回收
    
            bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
            return bitmap;
        }
    
        /**
         * 压缩图片(质量压缩)
         *
         * @param image
         */
    
        public static File compressImage(Bitmap image) {
    
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法,这里100表示不压缩,把压缩后的数据存放到baos中
            int options = 100;
    
            while (baos.toByteArray().length / 1024 > 100) {  //循环判断如果压缩后图片是否大于100kb,大于继续压缩
                baos.reset();//重置baos即清空baos
                options -= 10;//每次都减少10
                image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%,把压缩后的数据存放到baos中
                long length = baos.toByteArray().length;
            }
            File file = new File(Environment.getExternalStorageDirectory() + "/temp.png");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                try {
                    fos.write(baos.toByteArray());
                    fos.flush();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
    
            return file;
        }
    }
    

     我们压缩后最后得到的还是file将这个file扔给服务器就可以了。

     

     

    展开全文
  • 压缩图片我用了Luban 压缩运行出现了解决方案:implementation 'top.zibin:Luban:1.1.5' implementation "com.android.support:exifinterface:27.1.1"在导入依赖的时候应该再补上后面一个,这是因为...

    压缩图片我用了Luban 压缩


    运行出现了


    解决方案:

    implementation 'top.zibin:Luban:1.1.5'
    implementation "com.android.support:exifinterface:27.1.1"

    在导入依赖的时候应该再补上后面一个,这是因为android SDK最新的ExifInterface这个已经不在android.support.media.ExifInterface这个包里了,而在android.media.ExifInterface这个包里,而最新的这个包的使用必须minSdkVersion=24,所以要引入一个别的封装好的ExifInterface这个类。


    附LuBan地址:https://github.com/Curzibn/Luban


    展开全文
  • public Bitmap getimage(String srcPath) { BitmapFactory.Options newOpts = new ... // 开始读入图片,此时把options.inJustDecodeBounds 设回true了 newOpts.inJustDecodeBounds = true; Bitmap
    	public Bitmap getimage(String srcPath) {
    
    		BitmapFactory.Options newOpts = new BitmapFactory.Options();
    		// 开始读入图片,此时把options.inJustDecodeBounds 设回true了
    		newOpts.inJustDecodeBounds = true;
    		Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此时返回bm为空
    
    		newOpts.inJustDecodeBounds = false;
    		int w = newOpts.outWidth;
    		int h = newOpts.outHeight;
    
    		// 现在主流手机比较多是800*480分辨率,所以高和宽我们设置为
    		float hh = 800f;
    		float ww = 480f;
    		// 缩放比,只用高或者宽其中一个数据进行计算即可
    		int be = 1;// be=1表示不缩放
    		if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
    			be = (int) (newOpts.outWidth / ww);
    		} else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
    			be = (int) (newOpts.outHeight / hh);
    		}
    		if (be <= 0)
    			be = 1;
    		
    		newOpts.inSampleSize = be;// 设置缩放比例
    		// 重新读入图片,注意此时已经把options.inJustDecodeBounds 设回false了
    		bitmap = compressImage(BitmapFactory.decodeFile(srcPath, newOpts));
    		return bitmap;// 压缩好比例大小后再进行质量压缩
    	}
    
    	public Bitmap compressImage(Bitmap image) {
    
    		ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
    		// 质量压缩方法,这里100表示不压缩,把压缩后的数据存放到baos中
    		image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    		int options = 100;
    
    		// 循环判断如果压缩后图片是否大于300kb,大于继续压缩
    		while (baos.toByteArray().length / 1024 > 300) {
    
    			baos.reset();// 重置baos即清空baos
    			image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%,把压缩后的数据存放到baos中
    			options -= 10;// 每次都减少10
    		}
    
    		ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
    		Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
    		return bitmap;
    	}

    展开全文
  • 安卓图片压缩

    2019-09-25 21:48:41
    安卓图片压缩
  • 安卓联系拍照压缩图片分辨率
  • XE10.3.3 安卓图片压缩

    2020-04-20 09:42:35
    一种另类的图片压缩方法,支持比例压缩,固定宽度缩放。值得说明的是,这种压缩是锁定长宽比的。界面中只提供了按比例压缩。固定宽度压缩,在代码中自己调用
  • 靠谱的图片压缩方法图片压缩.zip,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • *尽量无损压缩图片,保持清晰度最优。可以对比原生方法bitmap.compress(CompressFormat.JPEG, quality, fileOutputStream); *占用内存少,支持压缩生成原图分辨率图片; *支持批量压缩,采用线程池提高性能 *支持...
  • 安卓图片压缩

    2019-03-07 15:57:37
    在讲压缩的方法之前我们先来了解两个概念 ...2.图片常用的压缩格式: 1.ALPHA_8 表示8位Alpha位图,即A=8,一个像素点占用1个字节,它没有颜色,只有透明度 2.ARGB_4444 表示16位ARGB位图,即A=4,R=4,G=4,B=4,一个...
  • 图片压缩,质量压缩,尺寸压缩,采样率压缩,使用jpeg进行压缩.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • Android安卓图片压缩

    千次阅读 2015-04-29 15:15:29
    android bitmap compress android的照相功能随着手机硬件的发展,变得越来越强大,能够找出很高分辨率的图片。 有些场景中,需要照相并且上传到服务,但是... 压缩图片。 照相时获取小图片一般不太符合要求,因
  • android安卓app图片压缩技术,一张将近3M的图片经过压缩后容量减小到186K,压缩效率达到16倍.zip
  • 在总结压缩之前,先了解下,安卓中常见的三种图片格式:PEPG,PNG,JPG JPEGJPEG(发音为jay-peg, IPA:[ˈdʒeɪpɛg])是一种针对照片视频而广泛使用的一种压缩标准方法。这个名称代表Joint Photographic Experts ...
  • 安卓图片压缩类,避免内存溢出OOM。 利用安卓自身的计算方法。
  • 安卓实现缩放、压缩、裁剪图片1、缩放2、压缩3、裁剪4、项目中 开始的时候:Bitmap是个什么东西? 后面:真香! 1、缩放 /** * 缩放图片 * @param bitmap * @param newWidth * @param newHeight * @return */ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 555
精华内容 222
关键字:

安卓压缩图片